@dative-gpi/foundation-core-services 0.0.2

package/composables/services/useDeviceOrganisations.ts

@@ -0,0 +1,92 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { ChangeDeviceOrganisationGroupDTO, ChangeDeviceOrganisationLocationDTO, CreateDeviceOrganisationDTO, DeviceOrganisationDetails, DeviceOrganisationDetailsDTO, DeviceOrganisationFilters, DeviceOrganisationInfos, DeviceOrganisationInfosDTO, UpdateDeviceOrganisationDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, onEntityChanged , ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { DEVICE_ORGANISATIONS_URL, DEVICE_ORGANISATION_URL, DEVICE_ORGANISATION_GROUP_URL, DEVICE_ORGANISATION_LOCATION_URL } from "../../config/urls";
+
+const DeviceOrganisationServiceFactory = new ServiceFactory<DeviceOrganisationDetailsDTO, DeviceOrganisationDetails>("deviceOrganisation", DeviceOrganisationDetails).create(factory => factory.build(
+    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) => ({
+        changeGroup: async (deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO): Promise<DeviceOrganisationDetails> => {
+            const response = await ServiceFactory.http.put(DEVICE_ORGANISATION_GROUP_URL(deviceOrganisationId), payload);
+            const result = new DeviceOrganisationDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        },
+        changeLocation: async (deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO): Promise<DeviceOrganisationDetails> => {
+            const response = await ServiceFactory.http.put(DEVICE_ORGANISATION_LOCATION_URL(deviceOrganisationId), payload);
+            const result = new DeviceOrganisationDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useDeviceOrganisation = ComposableFactory.get(DeviceOrganisationServiceFactory);
+export const useDeviceOrganisations = ComposableFactory.getMany(DeviceOrganisationServiceFactory);
+export const useCreateDeviceOrganisation = ComposableFactory.create(DeviceOrganisationServiceFactory);
+export const useUpdateDeviceOrganisation = ComposableFactory.update(DeviceOrganisationServiceFactory);
+export const useRemoveDeviceOrganisation = ComposableFactory.remove(DeviceOrganisationServiceFactory);
+export const useChangeDeviceOrganisationGroup = () => {
+    const service = DeviceOrganisationServiceFactory();
+
+    const changing = ref(false);
+    const changed = ref<DeviceOrganisationDetails | null>(null) as Ref<DeviceOrganisationDetails | null>;
+
+    const change = async (deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO) => {
+        changing.value = true;
+        try {
+            changed.value = await service.changeGroup(deviceOrganisationId, payload);
+        }
+        finally {
+            changing.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(changed))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(changed as Ref<DeviceOrganisationDetails>);
+    }
+
+    return {
+        changing: readonly(changing),
+        change,
+        changed: readonly(changed)
+    }
+}
+export const useChangeDeviceOrganisationLocation = () => {
+    const service = DeviceOrganisationServiceFactory();
+
+    const changing = ref(false);
+    const changed = ref<DeviceOrganisationDetails | null>(null) as Ref<DeviceOrganisationDetails | null>;
+
+    const change = async (deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO) => {
+        changing.value = true;
+        try {
+            changed.value = await service.changeLocation(deviceOrganisationId, payload);
+        }
+        finally {
+            changing.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(changed))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(changed as Ref<DeviceOrganisationDetails>);
+    }
+
+    return {
+        changing: readonly(changing),
+        change,
+        changed: readonly(changed)
+    }
+}

package/composables/services/useDeviceStatuses.ts

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

package/composables/services/useFamilies.ts

@@ -0,0 +1,13 @@
+import { FamilyDetails, FamilyDetailsDTO, FamilyFilters, FamilyInfos, FamilyInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { FAMILIES_URL, FAMILY_URL } from "../../config/urls";
+
+const FamilieserviceFactory = new ServiceFactory<FamilyDetailsDTO, FamilyDetails>("family", FamilyDetails).create(factory => factory.build(
+    factory.addGet(FAMILY_URL),
+    factory.addGetMany<FamilyInfosDTO, FamilyInfos, FamilyFilters>(FAMILIES_URL, FamilyInfos),
+    factory.addNotify()
+));
+
+export const useFamily = ComposableFactory.get(FamilieserviceFactory);
+export const useFamilies = ComposableFactory.getMany(FamilieserviceFactory);

package/composables/services/useGroups.ts

@@ -0,0 +1,57 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { ChangeGroupParentDTO, CreateGroupDTO, GroupDetails, GroupDetailsDTO, GroupFilters, GroupInfos, GroupInfosDTO, UpdateGroupDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, onEntityChanged , ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { GROUPS_URL, GROUP_URL } from "../../config/urls";
+
+const GroupServiceFactory = new ServiceFactory<GroupDetailsDTO, GroupDetails>("group", GroupDetails).create(factory => factory.build(
+    factory.addGet(GROUP_URL),
+    factory.addGetMany<GroupInfosDTO, GroupInfos, GroupFilters>(GROUPS_URL, GroupInfos),
+    factory.addCreate<CreateGroupDTO>(GROUPS_URL),
+    factory.addUpdate<UpdateGroupDTO>(GROUP_URL),
+    factory.addRemove(GROUP_URL),
+    factory.addNotify((notifyService) => ({
+        changeParent: async (groupId: string, payload: ChangeGroupParentDTO): Promise<GroupDetails> => {
+            const response = await ServiceFactory.http.put(GROUP_URL(groupId), payload);
+            const result = new GroupDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useGroup = ComposableFactory.get(GroupServiceFactory);
+export const useGroups = ComposableFactory.getMany(GroupServiceFactory);
+export const useCreateGroup = ComposableFactory.create(GroupServiceFactory);
+export const useUpdateGroup = ComposableFactory.update(GroupServiceFactory);
+export const useRemoveGroup = ComposableFactory.remove(GroupServiceFactory);
+export const useChangeGroupParent = () => {
+    const service = GroupServiceFactory();
+
+    const changing = ref(false);
+    const changed = ref<GroupDetails | null>(null) as Ref<GroupDetails | null>;
+
+    const change = async (groupId: string, payload: ChangeGroupParentDTO) => {
+        changing.value = true;
+        try {
+            changed.value = await service.changeParent(groupId, payload);
+        }
+        finally {
+            changing.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(changed))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(changed as Ref<GroupDetails>);
+    }
+
+    return {
+        changing: readonly(changing),
+        change,
+        changed: readonly(changed)
+    }
+}

package/composables/services/useLanguages.ts

@@ -0,0 +1,13 @@
+import { LanguageDetails, LanguageDetailsDTO, LanguageFilters, LanguageInfos, LanguageInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { LANGUAGES_URL, LANGUAGE_URL } from "../../config/urls";
+
+const LanguageServiceFactory = new ServiceFactory<LanguageDetailsDTO, LanguageDetails>("language", LanguageDetails).create(factory => factory.build(
+    factory.addGet(LANGUAGE_URL),
+    factory.addGetMany<LanguageInfosDTO, LanguageInfos, LanguageFilters>(LANGUAGES_URL, LanguageInfos),
+    factory.addNotify()
+));
+
+export const useLanguage = ComposableFactory.get(LanguageServiceFactory);
+export const useLanguages = ComposableFactory.getMany(LanguageServiceFactory);

package/composables/services/useLocations.ts

@@ -0,0 +1,13 @@
+import { CreateLocationDTO, LocationDetails, LocationDetailsDTO, LocationFilters, LocationInfos, LocationInfosDTO, UpdateLocationDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+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);
+
+export const useLocation = ComposableFactory.get(LocationServiceFactory);
+export const useLocations = ComposableFactory.getMany(LocationServiceFactory);
+export const useCreateLocation = ComposableFactory.create(LocationServiceFactory);
+export const useUpdateLocation = ComposableFactory.update(LocationServiceFactory);
+export const useRemoveLocation = ComposableFactory.remove(LocationServiceFactory);

package/composables/services/useManufacturers.ts

@@ -0,0 +1,13 @@
+import { ManufacturerDetails, ManufacturerDetailsDTO, ManufacturerFilters, ManufacturerInfos, ManufacturerInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+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()
+));
+
+export const useManufacturer = ComposableFactory.get(ManufacturerServiceFactory);
+export const useManufacturers = ComposableFactory.getMany(ManufacturerServiceFactory);

package/composables/services/useModels.ts

@@ -0,0 +1,13 @@
+import { ModelDetails, ModelDetailsDTO, ModelFilters, ModelInfos, ModelInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+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()
+));
+
+export const useModel = ComposableFactory.get(ModelServiceFactory);
+export const useModels = ComposableFactory.getMany(ModelServiceFactory);

package/composables/services/useOrganisationTypes.ts

@@ -0,0 +1,13 @@
+import { OrganisationTypeDetails, OrganisationTypeDetailsDTO, OrganisationTypeFilters, OrganisationTypeInfos, OrganisationTypeInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+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()
+));
+
+export const useOrganisationType = ComposableFactory.get(OrganisationTypeServiceFactory);
+export const useOrganisationTypes = ComposableFactory.getMany(OrganisationTypeServiceFactory);

package/composables/services/useOrganisations.ts

@@ -0,0 +1,53 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { ChangeOrganisationDashboardDTO, OrganisationDetails, OrganisationDetailsDTO, OrganisationFilters, OrganisationInfos, OrganisationInfosDTO, UpdateOrganisationDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, onEntityChanged , ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { ORGANISATION_DASHBOARD_URL, ORGANISATIONS_URL, ORGANISATION_URL } from "../../config/urls";
+
+const OrganisationServiceFactory = new ServiceFactory<OrganisationDetailsDTO, OrganisationDetails>("organisation", OrganisationDetails).create(factory => factory.build(
+    factory.addGet(ORGANISATION_URL),
+    factory.addGetMany<OrganisationInfosDTO, OrganisationInfos, OrganisationFilters>(ORGANISATIONS_URL, OrganisationInfos),
+    factory.addUpdate<UpdateOrganisationDTO>(ORGANISATION_URL),
+    factory.addNotify((notifyService) => ({
+        changeDashboard: async (payload: ChangeOrganisationDashboardDTO): Promise<OrganisationDetails> => {
+            const response = await ServiceFactory.http.put(ORGANISATION_DASHBOARD_URL, payload);
+            const result = new OrganisationDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useOrganisation = ComposableFactory.get(OrganisationServiceFactory);
+export const useOrganisations = ComposableFactory.getMany(OrganisationServiceFactory);
+export const useUpdateOrganisation = ComposableFactory.update(OrganisationServiceFactory);
+export const useChangeDashboardOrganisation = () => {
+    const service = OrganisationServiceFactory();
+
+    const changing = ref(false);
+    const changed = ref<OrganisationDetails | null>(null) as Ref<OrganisationDetails | null>;
+
+    const change = async (payload: ChangeOrganisationDashboardDTO) => {
+        changing.value = true;
+        try {
+            changed.value = await service.changeDashboard(payload);
+        }
+        finally {
+            changing.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(changed))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(changed as Ref<OrganisationDetails>);
+    }
+
+    return {
+        changing: readonly(changing),
+        change,
+        changed: readonly(changed)
+    }
+}

package/composables/services/usePermissionCategories.ts

@@ -0,0 +1,11 @@
+import { PermissionCategoryDetails, PermissionCategoryDetailsDTO, PermissionCategoryFilters, PermissionCategoryInfos, PermissionCategoryInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+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()
+));
+
+export const usePermissionCategories = ComposableFactory.getMany(PermissionCategoryServiceFactory);

package/composables/services/usePermissions.ts

@@ -0,0 +1,42 @@
+import { Ref, readonly, ref } from "vue";
+
+import { PermissionDetails, PermissionDetailsDTO, PermissionInfos, PermissionInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { PERMISSIONS_CURRENT_URL } from "../../config/urls";
+
+const PermissionServiceFactory = new ServiceFactory<PermissionDetailsDTO, PermissionDetails>("permission", PermissionDetails).create(factory => factory.build(
+    factory.addNotify(() => ({
+        getCurrent: async (): Promise<PermissionInfos[]> => {
+            const response = await ServiceFactory.http.get(PERMISSIONS_CURRENT_URL);
+            const result = response.data.map((dto: PermissionInfos) => new PermissionInfos(dto));
+
+            return result;
+        }
+    }))
+));
+
+export const useCurrentPermissions = () => {
+    const service = PermissionServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<PermissionInfos[] | null>(null) as Ref<PermissionInfos[] | null>;
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        return readonly(fetched as Ref<PermissionInfos[]>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useRoleOrganisationTypes.ts

@@ -0,0 +1,13 @@
+import { RoleOrganisationTypeDetails, RoleOrganisationTypeDetailsDTO, RoleOrganisationTypeFilters, RoleOrganisationTypeInfos, RoleOrganisationTypeInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+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()
+));
+
+export const useRoleOrganisationType = ComposableFactory.get(RoleOrganisationTypeServiceFactory);
+export const useRoleOrganisationTypes = ComposableFactory.getMany(RoleOrganisationTypeServiceFactory);

package/composables/services/useRoleOrganisations.ts

@@ -0,0 +1,13 @@
+import { CreateRoleOrganisationDTO, RoleOrganisationDetails, RoleOrganisationDetailsDTO, RoleOrganisationFilters, RoleOrganisationInfos, RoleOrganisationInfosDTO, UpdateRoleOrganisationDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { ROLE_ORGANISATIONS_URL, ROLE_ORGANISATION_URL } from "../../config/urls";
+
+const RoleOrganisationServiceFactory = new ServiceFactory<RoleOrganisationDetailsDTO, RoleOrganisationDetails>("roleOrganisation", RoleOrganisationDetails)
+    .createComplete<RoleOrganisationInfos, RoleOrganisationInfosDTO, CreateRoleOrganisationDTO, UpdateRoleOrganisationDTO, RoleOrganisationFilters>(ROLE_ORGANISATIONS_URL, ROLE_ORGANISATION_URL, RoleOrganisationInfos);
+
+export const useRoleOrganisation = ComposableFactory.get(RoleOrganisationServiceFactory);
+export const useRoleOrganisations = ComposableFactory.getMany(RoleOrganisationServiceFactory);
+export const useCreateRoleOrganisation = ComposableFactory.create(RoleOrganisationServiceFactory);
+export const useUpdateRoleOrganisation = ComposableFactory.update(RoleOrganisationServiceFactory);
+export const useRemoveRoleOrganisation = ComposableFactory.remove(RoleOrganisationServiceFactory);

package/composables/services/useTimeZones.ts

@@ -0,0 +1,11 @@
+import { TimeZoneFilters, TimeZoneInfos, TimeZoneInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { TIME_ZONES_URL } from "../../config/urls";
+
+const TimeZoneServiceFactory = new ServiceFactory<TimeZoneInfosDTO, TimeZoneInfos>("timeZone", TimeZoneInfos).create(factory => factory.build(
+    factory.addGetMany<TimeZoneInfosDTO, TimeZoneInfos, TimeZoneFilters>(TIME_ZONES_URL, TimeZoneInfos),
+    factory.addNotify()
+));
+
+export const useTimeZones = ComposableFactory.getMany(TimeZoneServiceFactory);

package/composables/services/useTranslations.ts

@@ -0,0 +1,42 @@
+import { Ref, readonly, ref } from "vue";
+
+import { TranslationInfos, TranslationInfosDTO, TranslationDetails, TranslationDetailsDTO } from "@dative-gpi/foundation-core-domain";
+import { ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { TRANSLATIONS_LANGUAGE_URL } from "../../config/urls";
+
+const TranslationServiceFactory = new ServiceFactory<TranslationDetailsDTO, TranslationDetails>("translation", TranslationDetails).create(factory => factory.build(
+    factory.addNotify(() => ({
+        getMany: async (languageCode: string): Promise<TranslationInfos[]> => {
+            const response = await ServiceFactory.http.get(TRANSLATIONS_LANGUAGE_URL(languageCode));
+            const result = response.data.map((dto: TranslationInfosDTO) => new TranslationInfos(dto));
+
+            return result;
+        }
+    }))
+));
+
+export const useTranslations = () => {
+    const service = TranslationServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<TranslationInfos[] | null>(null) as Ref<TranslationInfos[] | null>;
+
+    const fetch = async (languageCode: string) => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getMany(languageCode);
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        return readonly(fetched as Ref<TranslationInfos[]>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useUserOrganisations.ts

@@ -0,0 +1,92 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { CreateUserOrganisationDTO, UpdateUserOrganisationDTO, UserOrganisationDetails, UserOrganisationDetailsDTO, UserOrganisationFilters, UserOrganisationInfos, UserOrganisationInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { USER_ORGANISATIONS_URL, USER_ORGANISATION_CURRENT_URL, USER_ORGANISATION_URL } from "../../config/urls";
+
+const UserOrganisationServiceFactory = new ServiceFactory<UserOrganisationDetailsDTO, UserOrganisationDetails>("userOrganisation", UserOrganisationDetails).create(factory => factory.build(
+    factory.addGet(USER_ORGANISATION_URL),
+    factory.addGetMany<UserOrganisationInfosDTO, UserOrganisationInfos, UserOrganisationFilters>(USER_ORGANISATIONS_URL, UserOrganisationInfos),
+    factory.addCreate<CreateUserOrganisationDTO>(USER_ORGANISATIONS_URL),
+    factory.addUpdate<UpdateUserOrganisationDTO>(USER_ORGANISATION_URL),
+    factory.addRemove(USER_ORGANISATION_URL),
+    factory.addNotify((notifyService) => ({
+        getCurrent: async (): Promise<UserOrganisationDetails> => {
+            const response = await ServiceFactory.http.get(USER_ORGANISATION_CURRENT_URL);
+            const result = new UserOrganisationDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        },
+        updateCurrent: async(payload: UpdateUserOrganisationDTO): Promise<UserOrganisationDetails> => {
+            const response = await ServiceFactory.http.post(USER_ORGANISATION_CURRENT_URL, payload);
+            const result = new UserOrganisationDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useUserOrganisation = ComposableFactory.get(UserOrganisationServiceFactory);
+export const useUserOrganisations = ComposableFactory.getMany(UserOrganisationServiceFactory);
+export const useCreateUserOrganisation = ComposableFactory.create(UserOrganisationServiceFactory);
+export const useUpdateUserOrganisation = ComposableFactory.update(UserOrganisationServiceFactory);
+export const useRemoveUserOrganisation = ComposableFactory.remove(UserOrganisationServiceFactory);
+export const useCurrentUserOrganisation = () => {
+    const service = UserOrganisationServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<UserOrganisationDetails | null>(null) as Ref<UserOrganisationDetails | null>;
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(fetched))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(fetched as Ref<UserOrganisationDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}
+export const useUpdateCurrentUserOrganisation = () => {
+    const service = UserOrganisationServiceFactory();
+
+    const updating = ref(false);
+    const updated = ref<UserOrganisationDetails | null>(null) as Ref<UserOrganisationDetails | null>;
+
+    const update = async (payload: UpdateUserOrganisationDTO) => {
+        updating.value = true;
+        try {
+            updated.value = await service.updateCurrent(payload);
+        }
+        finally {
+            updating.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(updated))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(updated as Ref<UserOrganisationDetails>);
+    }
+
+    return {
+        updating: readonly(updating),
+        update,
+        updated: readonly(updated)
+    }
+}

package/composables/services/useUsers.ts

@@ -0,0 +1,90 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { UpdateUserDTO, UserDetails, UserDetailsDTO, UserFilters, UserInfos, UserInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { USERS_URL, USER_CURRENT_URL, USER_URL } from "../../config/urls";
+
+const UserServiceFactory = new ServiceFactory<UserDetailsDTO, UserDetails>("user", UserDetails).create(factory => factory.build(
+    factory.addGet(USER_URL),
+    factory.addGetMany<UserInfosDTO, UserInfos, UserFilters>(USERS_URL, UserInfos),
+    factory.addUpdate<UpdateUserDTO>(USER_URL),
+    factory.addRemove(USER_URL),
+    factory.addNotify((notifyService) => ({
+        getCurrent: async (): Promise<UserDetails> => {
+            const response = await ServiceFactory.http.get(USER_CURRENT_URL);
+            const result = new UserDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        },
+        updateCurrent: async(payload: UpdateUserDTO): Promise<UserDetails> => {
+            const response = await ServiceFactory.http.post(USER_CURRENT_URL, payload);
+            const result = new UserDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useUser = ComposableFactory.get(UserServiceFactory);
+export const useUsers = ComposableFactory.getMany(UserServiceFactory);
+export const useUpdateUser = ComposableFactory.update(UserServiceFactory);
+export const useRemoveUser = ComposableFactory.remove(UserServiceFactory);
+export const useCurrentUser = () => {
+    const service = UserServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<UserDetails | null>(null) as Ref<UserDetails | null>;
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(fetched))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(fetched as Ref<UserDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}
+export const useUpdateCurrentUser = () => {
+    const service = UserServiceFactory();
+
+    const updating = ref(false);
+    const updated = ref<UserDetails | null>(null) as Ref<UserDetails | null>;
+
+    const update = async (payload: UpdateUserDTO) => {
+        updating.value = true;
+        try {
+            updated.value = await service.updateCurrent(payload);
+        }
+        finally {
+            updating.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(updated))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(updated as Ref<UserDetails>);
+    }
+
+    return {
+        updating: readonly(updating),
+        update,
+        updated: readonly(updated)
+    }
+}