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

package/composables/services/useDeviceConnectivities.ts

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

package/composables/services/useDeviceOrganisations.ts

@@ -1,33 +1,32 @@
-import type { Ref } from "vue";
+import { type Ref } from "vue";
+
+import { type ChangeDeviceOrganisationGroupDTO, type ChangeDeviceOrganisationLocationDTO, type CreateDeviceOrganisationDTO, DeviceOrganisationDetails, type DeviceOrganisationDetailsDTO, type DeviceOrganisationFilters, DeviceOrganisationInfos, type DeviceOrganisationInfosDTO, type UpdateDeviceOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-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";
 
 import { useTrackDeviceConnectivity, useWatchDeviceConnectivity } from "./useDeviceConnectivities";
 import { useTrackDeviceStatuses, useWatchDeviceStatuses } from "./useDeviceStatuses";
 
-const DeviceOrganisationServiceFactory = new ServiceFactory<DeviceOrganisationDetailsDTO, DeviceOrganisationDetails>("deviceOrganisation", DeviceOrganisationDetails)
-  .create(factory => factory.build(
-    factory.addGet(DEVICE_ORGANISATION_URL),
-    factory.addGetMany<DeviceOrganisationInfosDTO, DeviceOrganisationInfos, DeviceOrganisationFilters>(DEVICE_ORGANISATIONS_URL, DeviceOrganisationInfos),
-    factory.addCreate<CreateDeviceOrganisationDTO>(DEVICE_ORGANISATIONS_URL),
-    factory.addUpdate<UpdateDeviceOrganisationDTO>(DEVICE_ORGANISATION_URL),
-    factory.addRemove(DEVICE_ORGANISATION_URL),
-    factory.addNotify(notifyService => ({
-      ...ServiceFactory.addCustom("changeGroup", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO) => axios.put(DEVICE_ORGANISATION_GROUP_URL(deviceOrganisationId), payload), (dto: DeviceOrganisationDetailsDTO) => {
-        const result = new DeviceOrganisationDetails(dto);
-        notifyService.notify("update", result);
-        return result;
-      }),
-      ...ServiceFactory.addCustom("changeLocation", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO) => axios.put(DEVICE_ORGANISATION_LOCATION_URL(deviceOrganisationId), payload), (dto: DeviceOrganisationDetailsDTO) => {
-        const result = new DeviceOrganisationDetails(dto);
-        notifyService.notify("update", result);
-        return result;
-      })
-    }))
-  ));
+const DeviceOrganisationServiceFactory = new ServiceFactory<DeviceOrganisationDetailsDTO, DeviceOrganisationDetails>("deviceOrganisation", DeviceOrganisationDetails).create(factory => factory.build(
+  factory.addGet(DEVICE_ORGANISATION_URL),
+  factory.addGetMany<DeviceOrganisationInfosDTO, DeviceOrganisationInfos, DeviceOrganisationFilters>(DEVICE_ORGANISATIONS_URL, DeviceOrganisationInfos),
+  factory.addCreate<CreateDeviceOrganisationDTO>(DEVICE_ORGANISATIONS_URL),
+  factory.addUpdate<UpdateDeviceOrganisationDTO>(DEVICE_ORGANISATION_URL),
+  factory.addRemove(DEVICE_ORGANISATION_URL),
+  factory.addNotify(notifyService => ({
+    ...ServiceFactory.addCustom("changeGroup", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO) => axios.put(DEVICE_ORGANISATION_GROUP_URL(deviceOrganisationId), payload), (dto: DeviceOrganisationDetailsDTO) => {
+      const result = new DeviceOrganisationDetails(dto);
+      notifyService.notify("update", result);
+      return result;
+    }),
+    ...ServiceFactory.addCustom("changeLocation", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO) => axios.put(DEVICE_ORGANISATION_LOCATION_URL(deviceOrganisationId), payload), (dto: DeviceOrganisationDetailsDTO) => {
+      const result = new DeviceOrganisationDetails(dto);
+      notifyService.notify("update", result);
+      return result;
+    })
+  }))
+));
 
 const trackDeviceOrganisation = () => {
   const { track: trackDeviceStatuses } = useTrackDeviceStatuses();
@@ -67,8 +66,6 @@ export const useDeviceOrganisation = ComposableFactory.get(DeviceOrganisationSer
 export const useDeviceOrganisations = ComposableFactory.getMany(DeviceOrganisationServiceFactory, trackDeviceOrganisations);
 export const useCreateDeviceOrganisation = ComposableFactory.create(DeviceOrganisationServiceFactory, trackDeviceOrganisation);
 export const useUpdateDeviceOrganisation = ComposableFactory.update(DeviceOrganisationServiceFactory, trackDeviceOrganisation);
-
 export const useRemoveDeviceOrganisation = ComposableFactory.remove(DeviceOrganisationServiceFactory);
-
 export const useChangeDeviceOrganisationGroup = ComposableFactory.custom(DeviceOrganisationServiceFactory.changeGroup, trackDeviceOrganisation);
-export const useChangeDeviceOrganisationLocation = ComposableFactory.custom(DeviceOrganisationServiceFactory.changeLocation, trackDeviceOrganisation);
+export const useChangeDeviceOrganisationLocation = ComposableFactory.custom(DeviceOrganisationServiceFactory.changeLocation, trackDeviceOrganisation);

package/composables/services/useDeviceStatuses.ts

@@ -1,26 +1,25 @@
-import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import type { DeviceStatusDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
-import { DeviceStatusDetails } from "@dative-gpi/foundation-core-domain/models";
+import { DeviceStatusDetails, type DeviceStatusDetailsDTO } 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 { DEVICE_STATUSES_HUB_URL, DEVICE_STATUS_URL } from "../../config/urls";
-import { HUBS } from "../../config/literals";
 
 const DeviceStatusServiceFactory = new ServiceFactory<DeviceStatusDetailsDTO, DeviceStatusDetails>("deviceStatus", DeviceStatusDetails).create(factory => factory.build(
-    factory.addGet(DEVICE_STATUS_URL),
-    factory.addNotify(notify => ({
-        notifyUpdate: (status: DeviceStatusDetails) => notify.notify("update", status)
-    }))
+  factory.addGet(DEVICE_STATUS_URL),
+  factory.addNotify(notify => ({
+    notifyUpdate: (status: DeviceStatusDetails) => notify.notify("update", status)
+  }))
 ));
 
 const useDeviceStatusesHub = HubFactory.create(DEVICE_STATUSES_HUB_URL,
-    (connection) => {
-        connection.on(HUBS.UPDATE_DEVICE_STATUS,
-            (payload: DeviceStatusDetailsDTO) => DeviceStatusServiceFactory.notifyUpdate(new DeviceStatusDetails(payload)));
-    },
-    async (connection) => {
-        await connection.invoke(HUBS.SUBSCRIBE);
-    }
+  (connection) => {
+    connection.on(HUBS.UPDATE_DEVICE_STATUS,
+      (payload: DeviceStatusDetailsDTO) => DeviceStatusServiceFactory.notifyUpdate(new DeviceStatusDetails(payload)));
+  },
+  async (connection) => {
+    await connection.invoke(HUBS.SUBSCRIBE);
+  }
 );
 
 export const useDeviceStatus = ComposableFactory.get(DeviceStatusServiceFactory);

package/composables/services/useFolders.ts

@@ -1,22 +1,19 @@
+import { type CreateFolderDTO, FolderDetails, type FolderDetailsDTO, type FolderFilters, FolderInfos, type FolderInfosDTO, type UpdateFolderDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-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";
 
-const FolderServiceFactory = new ServiceFactory<FolderDetailsDTO, FolderDetails>("folder", FolderDetails)
-  .create(factory => factory.build(
-    factory.addGet(FOLDER_URL),
-    factory.addGetMany<FolderInfosDTO, FolderInfos, FolderFilters>(FOLDERS_URL, FolderInfos),
-    factory.addCreate<CreateFolderDTO>(FOLDERS_URL),
-    factory.addUpdate<UpdateFolderDTO>(FOLDER_URL),
-    factory.addRemove(FOLDER_URL),
-    factory.addNotify()
-  ));
+const FolderServiceFactory = new ServiceFactory<FolderDetailsDTO, FolderDetails>("folder", FolderDetails).create(factory => factory.build(
+  factory.addGet(FOLDER_URL),
+  factory.addGetMany<FolderInfosDTO, FolderInfos, FolderFilters>(FOLDERS_URL, FolderInfos),
+  factory.addCreate<CreateFolderDTO>(FOLDERS_URL),
+  factory.addUpdate<UpdateFolderDTO>(FOLDER_URL),
+  factory.addRemove(FOLDER_URL),
+  factory.addNotify()
+));
 
 export const useFolder = ComposableFactory.get(FolderServiceFactory);
 export const useFolders = ComposableFactory.getMany(FolderServiceFactory);
 export const useCreateFolder = ComposableFactory.create(FolderServiceFactory);
 export const useUpdateFolder = ComposableFactory.update(FolderServiceFactory);
-export const useRemoveFolder = ComposableFactory.remove(FolderServiceFactory);
-
+export const useRemoveFolder = ComposableFactory.remove(FolderServiceFactory);

package/composables/services/useGroups.ts

@@ -1,5 +1,4 @@
-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 { type ChangeGroupParentDTO, type CreateGroupDTO, GroupDetails, type GroupDetailsDTO, type GroupFilters, GroupInfos, type GroupInfosDTO, type UpdateGroupDTO } 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

@@ -4,7 +4,7 @@ import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 import { LOCATIONS_URL, LOCATION_URL } from "../../config/urls";
 
 const LocationServiceFactory = new ServiceFactory<LocationDetailsDTO, LocationDetails>("location", LocationDetails)
-    .createComplete<LocationInfos, LocationInfosDTO, CreateLocationDTO, UpdateLocationDTO, LocationFilters>(LOCATIONS_URL, LOCATION_URL, LocationInfos);
+  .createComplete<LocationInfos, LocationInfosDTO, CreateLocationDTO, UpdateLocationDTO, LocationFilters>(LOCATIONS_URL, LOCATION_URL, LocationInfos);
 
 export const useLocation = ComposableFactory.get(LocationServiceFactory);
 export const useLocations = ComposableFactory.getMany(LocationServiceFactory);

package/composables/services/useManufacturers.ts

@@ -1,13 +1,12 @@
-import type { ManufacturerDetailsDTO, ManufacturerFilters, ManufacturerInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ManufacturerDetails, ManufacturerInfos } from "@dative-gpi/foundation-core-domain/models";
+import { ManufacturerDetails, type ManufacturerDetailsDTO, type ManufacturerFilters, ManufacturerInfos, type ManufacturerInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { MANUFACTURERS_URL, MANUFACTURER_URL } from "../../config/urls";
 
 const ManufacturerServiceFactory = new ServiceFactory<ManufacturerDetailsDTO, ManufacturerDetails>("manufacturer", ManufacturerDetails).create(factory => factory.build(
-    factory.addGet(MANUFACTURER_URL),
-    factory.addGetMany<ManufacturerInfosDTO, ManufacturerInfos, ManufacturerFilters>(MANUFACTURERS_URL, ManufacturerInfos),
-    factory.addNotify()
+  factory.addGet(MANUFACTURER_URL),
+  factory.addGetMany<ManufacturerInfosDTO, ManufacturerInfos, ManufacturerFilters>(MANUFACTURERS_URL, ManufacturerInfos),
+  factory.addNotify()
 ));
 
 export const useManufacturer = ComposableFactory.get(ManufacturerServiceFactory);

package/composables/services/useModels.ts

@@ -4,9 +4,9 @@ import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 import { MODELS_URL, MODEL_URL } from "../../config/urls";
 
 const ModelServiceFactory = new ServiceFactory<ModelDetailsDTO, ModelDetails>("model", ModelDetails).create(factory => factory.build(
-    factory.addGet(MODEL_URL),
-    factory.addGetMany<ModelInfosDTO, ModelInfos, ModelFilters>(MODELS_URL, ModelInfos),
-    factory.addNotify()
+  factory.addGet(MODEL_URL),
+  factory.addGetMany<ModelInfosDTO, ModelInfos, ModelFilters>(MODELS_URL, ModelInfos),
+  factory.addNotify()
 ));
 
 export const useModel = ComposableFactory.get(ModelServiceFactory);

package/composables/services/useOrganisationTypes.ts

@@ -1,13 +1,12 @@
-import type { OrganisationTypeDetailsDTO, OrganisationTypeFilters, OrganisationTypeInfosDTO } from "@dative-gpi/foundation-shared-domain/models";
-import { OrganisationTypeDetails, OrganisationTypeInfos } from "@dative-gpi/foundation-shared-domain/models";
+import { OrganisationTypeDetails, type OrganisationTypeDetailsDTO, type OrganisationTypeFilters, OrganisationTypeInfos, type OrganisationTypeInfosDTO } 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";
 
 const OrganisationTypeServiceFactory = new ServiceFactory<OrganisationTypeDetailsDTO, OrganisationTypeDetails>("organisationType", OrganisationTypeDetails).create(factory => factory.build(
-    factory.addGet(ORGANISATION_TYPE_URL),
-    factory.addGetMany<OrganisationTypeInfosDTO, OrganisationTypeInfos, OrganisationTypeFilters>(ORGANISATION_TYPES_URL, OrganisationTypeInfos),
-    factory.addNotify()
+  factory.addGet(ORGANISATION_TYPE_URL),
+  factory.addGetMany<OrganisationTypeInfosDTO, OrganisationTypeInfos, OrganisationTypeFilters>(ORGANISATION_TYPES_URL, OrganisationTypeInfos),
+  factory.addNotify()
 ));
 
 export const useOrganisationType = ComposableFactory.get(OrganisationTypeServiceFactory);

package/composables/services/useOrganisations.ts

@@ -1,18 +1,17 @@
-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 { OrganisationDetails, type OrganisationDetailsDTO } 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";
 
 const OrganisationServiceFactory = new ServiceFactory<OrganisationDetailsDTO, OrganisationDetails>("organisation", OrganisationDetails).create(factory => factory.build(
-    factory.addNotify(notifyService => ({
-        ...ServiceFactory.addCustom("changeDashboard", (axios, payload: ChangeOrganisationDashboardDTO) => axios.put(ORGANISATION_DASHBOARD_URL(), payload), (dto: OrganisationDetailsDTO) => {
-            const result = new OrganisationDetails(dto);
-            notifyService.notify("update", result);
-            return result;
-        })
-    }))
+  factory.addNotify(notifyService => ({
+    ...ServiceFactory.addCustom("changeDashboard", (axios, payload: ChangeOrganisationDashboardDTO) => axios.put(ORGANISATION_DASHBOARD_URL(), payload), (dto: OrganisationDetailsDTO) => {
+      const result = new OrganisationDetails(dto);
+      notifyService.notify("update", result);
+      return result;
+    })
+  }))
 ));
 
 export const useChangeDashboardOrganisation = ComposableFactory.custom(OrganisationServiceFactory.changeDashboard);

package/composables/services/usePermissionCategories.ts

@@ -1,12 +1,11 @@
-import type { PermissionCategoryDetailsDTO, PermissionCategoryFilters, PermissionCategoryInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { PermissionCategoryDetails, PermissionCategoryInfos } from "@dative-gpi/foundation-core-domain/models";
+import { PermissionCategoryDetails, type PermissionCategoryDetailsDTO, type PermissionCategoryFilters, PermissionCategoryInfos, type PermissionCategoryInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { PERMISSION_CATEGORIES_URL } from "../../config/urls";
 
 const PermissionCategoryServiceFactory = new ServiceFactory<PermissionCategoryDetailsDTO, PermissionCategoryDetails>("permissionCategory", PermissionCategoryDetails).create(factory => factory.build(
-    factory.addGetMany<PermissionCategoryInfosDTO, PermissionCategoryInfos, PermissionCategoryFilters>(PERMISSION_CATEGORIES_URL, PermissionCategoryInfos),
-    factory.addNotify()
+  factory.addGetMany<PermissionCategoryInfosDTO, PermissionCategoryInfos, PermissionCategoryFilters>(PERMISSION_CATEGORIES_URL, PermissionCategoryInfos),
+  factory.addNotify()
 ));
 
 export const usePermissionCategories = ComposableFactory.getMany(PermissionCategoryServiceFactory);

package/composables/services/useRoleOrganisationTypes.ts

@@ -1,13 +1,12 @@
-import type { RoleOrganisationTypeDetailsDTO, RoleOrganisationTypeFilters, RoleOrganisationTypeInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { RoleOrganisationTypeDetails, RoleOrganisationTypeInfos } from "@dative-gpi/foundation-core-domain/models";
+import { RoleOrganisationTypeDetails, type RoleOrganisationTypeDetailsDTO, type RoleOrganisationTypeFilters, RoleOrganisationTypeInfos, type RoleOrganisationTypeInfosDTO } 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";
 
 const RoleOrganisationTypeServiceFactory = new ServiceFactory<RoleOrganisationTypeDetailsDTO, RoleOrganisationTypeDetails>("roleOrganisationType", RoleOrganisationTypeDetails).create(factory => factory.build(
-    factory.addGet(ROLE_ORGANISATION_TYPE_URL),
-    factory.addGetMany<RoleOrganisationTypeInfosDTO, RoleOrganisationTypeInfos, RoleOrganisationTypeFilters>(ROLE_ORGANISATION_TYPES_URL, RoleOrganisationTypeInfos),
-    factory.addNotify()
+  factory.addGet(ROLE_ORGANISATION_TYPE_URL),
+  factory.addGetMany<RoleOrganisationTypeInfosDTO, RoleOrganisationTypeInfos, RoleOrganisationTypeFilters>(ROLE_ORGANISATION_TYPES_URL, RoleOrganisationTypeInfos),
+  factory.addNotify()
 ));
 
 export const useRoleOrganisationType = ComposableFactory.get(RoleOrganisationTypeServiceFactory);

package/composables/services/useRoleOrganisations.ts

@@ -1,5 +1,4 @@
-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 { type CreateRoleOrganisationDTO, RoleOrganisationDetails, type RoleOrganisationDetailsDTO, type RoleOrganisationFilters, RoleOrganisationInfos, type RoleOrganisationInfosDTO, type UpdateRoleOrganisationDTO } 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

@@ -1,15 +1,21 @@
+import { type CreateManyScenarioDeviceOrganisationDTO, type CreateScenarioDeviceOrganisationDTO, ScenarioDeviceOrganisationDetails, type ScenarioDeviceOrganisationDetailsDTO, type ScenarioDeviceOrganisationFilters, ScenarioDeviceOrganisationInfos, type ScenarioDeviceOrganisationInfosDTO, type UpdateScenarioDeviceOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
 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);
 
+const ScenarioDeviceOrganisationServiceFactoryIncomplete = new ServiceFactory<ScenarioDeviceOrganisationInfosDTO, ScenarioDeviceOrganisationInfos>("notifications", ScenarioDeviceOrganisationDetails).create(factory => factory.build(
+  factory.addNotify(() => ({
+    ...ServiceFactory.addCustom("createMany", (axios, payload: CreateManyScenarioDeviceOrganisationDTO) => axios.put(SCENARIO_DEVICE_ORGANISATIONS_URL(), payload), () => {
+    })
+  }))
+));
+
 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);
-
+export const useCreateManyScenarioDeviceOrganisation = ComposableFactory.custom(ScenarioDeviceOrganisationServiceFactoryIncomplete.createMany);

package/composables/services/useScenarioOrganisationTypes.ts

@@ -1,28 +1,27 @@
+import { type CreateScenarioOrganisationTypeDTO, ScenarioOrganisationTypeDetails, type ScenarioOrganisationTypeDetailsDTO, type ScenarioOrganisationTypeFilters, ScenarioOrganisationTypeInfos, type ScenarioOrganisationTypeInfosDTO, type UpdateScenarioOrganisationTypeDTO } from "@dative-gpi/foundation-core-domain/models";
 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;
-            })
-        }))
-    ));
+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);

package/composables/services/useScenarioOrganisations.ts

@@ -1,22 +1,20 @@
+import { type CreateScenarioOrganisationDTO, ScenarioOrganisationDetails, type ScenarioOrganisationDetailsDTO, type ScenarioOrganisationFilters, ScenarioOrganisationInfos, type ScenarioOrganisationInfosDTO, type UpdateScenarioOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
 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";
 
+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;
-            })
-        })
-    )));
+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);

package/composables/services/useServiceAccountOrganisationAuthTokens.ts

@@ -1,20 +1,15 @@
-import type { ServiceAccountOrganisationAuthTokenDetailsDTO, ServiceAccountOrganisationAuthTokenFilters, CreateServiceAccountOrganisationAuthTokenDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ServiceAccountOrganisationAuthTokenDetails } from "@dative-gpi/foundation-core-domain/models";
+import { type CreateServiceAccountOrganisationAuthTokenDTO, ServiceAccountOrganisationAuthTokenDetails, type ServiceAccountOrganisationAuthTokenDetailsDTO, type ServiceAccountOrganisationAuthTokenFilters, ServiceAccountOrganisationAuthTokenInfos, type ServiceAccountOrganisationAuthTokenInfosDTO } 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)), () => {})
-    }))
+  factory.addGetMany<ServiceAccountOrganisationAuthTokenInfosDTO, ServiceAccountOrganisationAuthTokenInfos, ServiceAccountOrganisationAuthTokenFilters>(SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKENS_URL, ServiceAccountOrganisationAuthTokenInfos),
+  factory.addCreate<CreateServiceAccountOrganisationAuthTokenDTO>(SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKENS_URL),
+  factory.addRemove(SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKEN_URL),
+  factory.addNotify()
 ));
 
-export const useServiceAccountOrganisationAuthTokens = ComposableFactory.custom(ServiceAccountOrganisationAuthTokenServiceFactory.getMany);
-export const useCreateServiceAccountOrganisationAuthToken = ComposableFactory.custom(ServiceAccountOrganisationAuthTokenServiceFactory.create);
-export const useRemoveServiceAccountOrganisationAuthToken = ComposableFactory.custom(ServiceAccountOrganisationAuthTokenServiceFactory.remove);
+export const useServiceAccountOrganisationAuthTokens = ComposableFactory.getMany(ServiceAccountOrganisationAuthTokenServiceFactory);
+export const useCreateServiceAccountOrganisationAuthToken = ComposableFactory.create(ServiceAccountOrganisationAuthTokenServiceFactory);
+export const useRemoveServiceAccountOrganisationAuthToken = ComposableFactory.remove(ServiceAccountOrganisationAuthTokenServiceFactory);

package/composables/services/useServiceAccountOrganisations.ts

@@ -1,11 +1,10 @@
+import { type CreateServiceAccountOrganisationDTO, ServiceAccountOrganisationDetails, type ServiceAccountOrganisationDetailsDTO, type ServiceAccountOrganisationFilters, ServiceAccountOrganisationInfos, type ServiceAccountOrganisationInfosDTO, type UpdateServiceAccountOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
 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);
+  .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);

package/composables/services/useServiceAccountRoleOrganisations.ts

@@ -0,0 +1,13 @@
+import { type CreateServiceAccountRoleOrganisationDTO, ServiceAccountRoleOrganisationDetails, type ServiceAccountRoleOrganisationDetailsDTO, type ServiceAccountRoleOrganisationFilters, ServiceAccountRoleOrganisationInfos, type ServiceAccountRoleOrganisationInfosDTO, type UpdateServiceAccountRoleOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+
+import { SERVICE_ACCOUNT_ROLE_ORGANISATIONS_URL, SERVICE_ACCOUNT_ROLE_ORGANISATION_URL } from "../../config/urls";
+
+const ServiceAccountRoleOrganisationServiceFactory = new ServiceFactory<ServiceAccountRoleOrganisationDetailsDTO, ServiceAccountRoleOrganisationDetails>("serviceAccountOrganisation", ServiceAccountRoleOrganisationDetails)
+  .createComplete<ServiceAccountRoleOrganisationInfos, ServiceAccountRoleOrganisationInfosDTO, CreateServiceAccountRoleOrganisationDTO, UpdateServiceAccountRoleOrganisationDTO, ServiceAccountRoleOrganisationFilters>(SERVICE_ACCOUNT_ROLE_ORGANISATIONS_URL, SERVICE_ACCOUNT_ROLE_ORGANISATION_URL, ServiceAccountRoleOrganisationInfos);
+
+export const useServiceAccountRoleOrganisation = ComposableFactory.get(ServiceAccountRoleOrganisationServiceFactory);
+export const useServiceAccountRoleOrganisations = ComposableFactory.getMany(ServiceAccountRoleOrganisationServiceFactory);
+export const useCreateServiceAccountRoleOrganisation = ComposableFactory.create(ServiceAccountRoleOrganisationServiceFactory);
+export const useUpdateServiceAccountRoleOrganisation = ComposableFactory.update(ServiceAccountRoleOrganisationServiceFactory);
+export const useRemoveServiceAccountRoleOrganisation = ComposableFactory.remove(ServiceAccountRoleOrganisationServiceFactory);

package/composables/services/useUserOrganisationTables.ts

@@ -1,15 +1,13 @@
-import type { UserOrganisationTableDetailsDTO, UpdateUserOrganisationTableDTO } from "@dative-gpi/foundation-core-domain/models";
-import { UserOrganisationTableDetails } from "@dative-gpi/foundation-core-domain/models";
+import { type UpdateUserOrganisationTableDTO, UserOrganisationTableDetails, type UserOrganisationTableDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { USER_ORGANISATION_TABLE_URL } from "../../config/urls";
 
 const UserOrganisationTableServiceFactory = new ServiceFactory<UserOrganisationTableDetailsDTO, UserOrganisationTableDetails>("userOrgansiationTable", UserOrganisationTableDetails).create(factory => factory.build(
-    factory.addGet(USER_ORGANISATION_TABLE_URL),
-    factory.addUpdate<UpdateUserOrganisationTableDTO>(USER_ORGANISATION_TABLE_URL),
-    factory.addNotify()
+  factory.addGet(USER_ORGANISATION_TABLE_URL),
+  factory.addUpdate<UpdateUserOrganisationTableDTO>(USER_ORGANISATION_TABLE_URL),
+  factory.addNotify()
 ));
 
-
 export const useUserOrganisationTable = ComposableFactory.get(UserOrganisationTableServiceFactory);
 export const useUpdateUserOrganisationTable = ComposableFactory.update(UserOrganisationTableServiceFactory);