@dative-gpi/foundation-shared-services 0.0.8 → 0.0.10

package/composables/index.ts

@@ -1,2 +1,5 @@
+export * from "./services";
 export * from "./useLanguageCode";
-export * from "./useTimeZone";
+export * from "./useShared";
+export * from "./useTimeZone";
+export * from "./useTranslationsProvider";

package/composables/services/index.ts

@@ -0,0 +1,13 @@
+export * from "./useApplications";
+export * from "./useAuthTokens";
+export * from "./useFrequentlyAskedQuestions";
+export * from "./useImages";
+export * from "./useLandingPages";
+export * from "./useLayoutPages";
+export * from "./useLegalInformations";
+export * from "./useOrganisations";
+export * from "./useSecuritySettings";
+export * from "./useTimeZones";
+export * from "./useTranslations";
+export * from "./useUserLegalInformations";
+export * from "./useUsers"; 

package/composables/services/useApplications.ts

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

package/composables/services/useAuthTokens.ts

@@ -0,0 +1,11 @@
+import { AuthTokenDetails, AuthTokenDetailsDTO, CreateAuthTokenDTO } from "@dative-gpi/foundation-shared-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { AUTH_TOKENS_URL } from "../../config/urls";
+
+const AuthTokenServiceFactory = new ServiceFactory<AuthTokenDetailsDTO, AuthTokenDetails>("authToken", AuthTokenDetails).create(factory => factory.build(
+    factory.addCreate<CreateAuthTokenDTO>(AUTH_TOKENS_URL),
+    factory.addNotify()
+));
+
+export const useCreateAuthToken = ComposableFactory.create(AuthTokenServiceFactory);

package/composables/services/useFrequentlyAskedQuestions.ts

@@ -0,0 +1,11 @@
+import { FrequentlyAskedQuestionDetails, FrequentlyAskedQuestionDetailsDTO, FrequentlyAskedQuestionFilters, FrequentlyAskedQuestionInfos, FrequentlyAskedQuestionInfosDTO } from "@dative-gpi/foundation-shared-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { FREQUENTLY_ASKED_QUESTIONS_URL } from "../../config/urls";
+
+const FrequentlyAskedQuestionServiceFactory = new ServiceFactory<FrequentlyAskedQuestionDetailsDTO, FrequentlyAskedQuestionDetails>("frequentlyAskedQuestions", FrequentlyAskedQuestionDetails).create(factory => factory.build(
+    factory.addGetMany<FrequentlyAskedQuestionInfosDTO, FrequentlyAskedQuestionInfos, FrequentlyAskedQuestionFilters>(FREQUENTLY_ASKED_QUESTIONS_URL, FrequentlyAskedQuestionInfos),
+    factory.addNotify()
+));
+
+export const useFrequentlyAskedQuestions = ComposableFactory.getMany(FrequentlyAskedQuestionServiceFactory);

package/composables/services/useImages.ts

@@ -0,0 +1,71 @@
+import { Ref, readonly, ref } from "vue";
+
+import { BlurHash } from "@dative-gpi/foundation-shared-domain";
+import { ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { IMAGE_RAW_URL, IMAGE_BLURHASH_URL } from "../../config/urls";
+
+const ImageServiceFactory = new ServiceFactory("image", BlurHash).create(factory => factory.build(
+    factory.addNotify(() => ({
+        getRaw: async (imageId: string): Promise<string> => {
+            const response = await ServiceFactory.http.get(IMAGE_RAW_URL(imageId));
+
+            return response.data;
+        },
+        getBlurHash: async (imageId: string): Promise<BlurHash> => {
+            const response = await ServiceFactory.http.get(IMAGE_BLURHASH_URL(imageId));
+            const result = new BlurHash(response.data);
+
+            return result;
+        }
+    }))
+));
+
+export const useImageRaw = () => {
+    const service = ImageServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<string | null>(null) as Ref<string | null>;
+
+    const fetch = async (imageId: string) => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getRaw(imageId);
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        return readonly(fetched as Ref<string>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}
+export const useImageBlurHash = () => {
+    const service = ImageServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<BlurHash | null>(null) as Ref<BlurHash | null>;
+
+    const fetch = async (imageId: string) => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getBlurHash(imageId);
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        return readonly(fetched as Ref<BlurHash>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useLandingPages.ts

@@ -0,0 +1,50 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { LandingPageDetails, LandingPageDetailsDTO } from "@dative-gpi/foundation-shared-domain";
+import { onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { LANDING_PAGE_CURRENT_URL } from "../../config/urls";
+
+const LandingPageServiceFactory = new ServiceFactory<LandingPageDetailsDTO, LandingPageDetails>("landingPage", LandingPageDetails).create(factory => factory.build(
+    factory.addNotify((notifyService) => ({
+        getCurrent: async (): Promise<LandingPageDetails> => {
+            const response = await ServiceFactory.http.get(LANDING_PAGE_CURRENT_URL());
+            const result = new LandingPageDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useCurrentLandingPage = () => {
+    const service = LandingPageServiceFactory();
+    const subscribersIds: number[] = [];
+
+    const fetching = ref(false);
+    const fetched = ref<LandingPageDetails | null>(null) as Ref<LandingPageDetails | null>;
+
+    onUnmounted(() => {
+        subscribersIds.forEach(id => service.unsubscribe(id));
+        subscribersIds.length = 0;
+    });
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+        subscribersIds.push(service.subscribe("all", onEntityChanged(fetched)));
+        return readonly(fetched as Ref<LandingPageDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useLayoutPages.ts

@@ -0,0 +1,50 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { LayoutPageDetails, LayoutPageDetailsDTO } from "@dative-gpi/foundation-shared-domain";
+import { onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { LAYOUT_PAGE_CURRENT_URL } from "../../config/urls";
+
+const LayoutPageServiceFactory = new ServiceFactory<LayoutPageDetailsDTO, LayoutPageDetails>("layoutPage", LayoutPageDetails).create(factory => factory.build(
+    factory.addNotify((notifyService) => ({
+        getCurrent: async (): Promise<LayoutPageDetails> => {
+            const response = await ServiceFactory.http.get(LAYOUT_PAGE_CURRENT_URL());
+            const result = new LayoutPageDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useCurrentLayoutPage = () => {
+    const service = LayoutPageServiceFactory();
+    const subscribersIds: number[] = [];
+
+    const fetching = ref(false);
+    const fetched = ref<LayoutPageDetails | null>(null) as Ref<LayoutPageDetails | null>;
+
+    onUnmounted(() => {
+        subscribersIds.forEach(id => service.unsubscribe(id));
+        subscribersIds.length = 0;
+    });
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+        subscribersIds.push(service.subscribe("all", onEntityChanged(fetched)));
+        return readonly(fetched as Ref<LayoutPageDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useLegalInformations.ts

@@ -0,0 +1,50 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { LegalInformationDetails, LegalInformationDetailsDTO } from "@dative-gpi/foundation-shared-domain";
+import { onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { LEGAL_INFORMATION_CURRENT_URL } from "../../config/urls";
+
+const LegalInformationServiceFactory = new ServiceFactory<LegalInformationDetailsDTO, LegalInformationDetails>("legalInformation", LegalInformationDetails).create(factory => factory.build(
+    factory.addNotify((notifyService) => ({
+        getCurrent: async (): Promise<LegalInformationDetails> => {
+            const response = await ServiceFactory.http.get(LEGAL_INFORMATION_CURRENT_URL());
+            const result = new LegalInformationDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useCurrentLegalInformation = () => {
+    const service = LegalInformationServiceFactory();
+    const subscribersIds: number[] = [];
+
+    const fetching = ref(false);
+    const fetched = ref<LegalInformationDetails | null>(null) as Ref<LegalInformationDetails | null>;
+
+    onUnmounted(() => {
+        subscribersIds.forEach(id => service.unsubscribe(id));
+        subscribersIds.length = 0;
+    });
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+        subscribersIds.push(service.subscribe("all", onEntityChanged(fetched)));
+        return readonly(fetched as Ref<LegalInformationDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useOrganisations.ts

@@ -0,0 +1,17 @@
+import { CreateOrganisationDTO, OrganisationDetails, OrganisationDetailsDTO, OrganisationFilters, OrganisationInfos, OrganisationInfosDTO, UpdateOrganisationDTO } from "@dative-gpi/foundation-shared-domain";
+import { ComposableFactory , ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { 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.addCreate<CreateOrganisationDTO>(ORGANISATIONS_URL),
+    factory.addUpdate<UpdateOrganisationDTO>(ORGANISATION_URL),
+    factory.addNotify()
+));
+
+export const useOrganisation = ComposableFactory.get(OrganisationServiceFactory);
+export const useOrganisations = ComposableFactory.getMany(OrganisationServiceFactory);
+export const useCreateOrganisation = ComposableFactory.create(OrganisationServiceFactory);
+export const useUpdateOrganisation = ComposableFactory.update(OrganisationServiceFactory);

package/composables/services/useSecuritySettings.ts

@@ -0,0 +1,50 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { SecuritySettingDetails, SecuritySettingDetailsDTO } from "@dative-gpi/foundation-shared-domain";
+import { onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { SECURITY_SETTING_CURRENT_URL } from "../../config/urls";
+
+const SecuritySettingServiceFactory = new ServiceFactory<SecuritySettingDetailsDTO, SecuritySettingDetails>("securitySetting", SecuritySettingDetails).create(factory => factory.build(
+    factory.addNotify((notifyService) => ({
+        getCurrent: async (): Promise<SecuritySettingDetails> => {
+            const response = await ServiceFactory.http.get(SECURITY_SETTING_CURRENT_URL());
+            const result = new SecuritySettingDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useCurrentSecuritySettings = () => {
+    const service = SecuritySettingServiceFactory();
+    const subscribersIds: number[] = [];
+
+    const fetching = ref(false);
+    const fetched = ref<SecuritySettingDetails | null>(null) as Ref<SecuritySettingDetails | null>;
+
+    onUnmounted(() => {
+        subscribersIds.forEach(id => service.unsubscribe(id));
+        subscribersIds.length = 0;
+    });
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+        subscribersIds.push(service.subscribe("all", onEntityChanged(fetched)));
+        return readonly(fetched as Ref<SecuritySettingDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useTimeZones.ts

@@ -0,0 +1,11 @@
+import { TimeZoneFilters, TimeZoneInfos, TimeZoneInfosDTO } from "@dative-gpi/foundation-shared-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-shared-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[]>([]) as Ref<TranslationInfos[]>;
+
+    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/useUserLegalInformations.ts

@@ -0,0 +1,52 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { CreateUserLegalInformationDTO, UserLegalInformationDetails, UserLegalInformationDetailsDTO } from "@dative-gpi/foundation-shared-domain";
+import { ComposableFactory, onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { USER_LEGAL_INFORMATIONS_URL, USER_LEGAL_INFORMATION_CURRENT_URL } from "../../config/urls";
+
+const UserLegalInformationServiceFactory = new ServiceFactory<UserLegalInformationDetailsDTO, UserLegalInformationDetails>("userLegalInformation", UserLegalInformationDetails).create(factory => factory.build(
+    factory.addCreate<CreateUserLegalInformationDTO>(USER_LEGAL_INFORMATIONS_URL),
+    factory.addNotify((notifyService) => ({
+        getCurrent: async (): Promise<UserLegalInformationDetails> => {
+            const response = await ServiceFactory.http.get(USER_LEGAL_INFORMATION_CURRENT_URL());
+            const result = new UserLegalInformationDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useCreateUserLegalInformation = ComposableFactory.create(UserLegalInformationServiceFactory);
+export const useCurrentUserLegalInformation = () => {
+    const service = UserLegalInformationServiceFactory();
+    const subscribersIds: number[] = [];
+
+    const fetching = ref(false);
+    const fetched = ref<UserLegalInformationDetails | null>(null) as Ref<UserLegalInformationDetails | null>;
+
+    onUnmounted(() => {
+        subscribersIds.forEach(id => service.unsubscribe(id));
+        subscribersIds.length = 0;
+    });
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+        subscribersIds.push(service.subscribe("all", onEntityChanged(fetched)));
+        return readonly(fetched as Ref<UserLegalInformationDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useUsers.ts

@@ -0,0 +1,88 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { UpdateUserDTO, UserDetails, UserDetailsDTO } from "@dative-gpi/foundation-shared-domain";
+import { onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { USER_CURRENT_URL } from "../../config/urls";
+
+const UserServiceFactory = new ServiceFactory<UserDetailsDTO, UserDetails>("user", UserDetails).create(factory => factory.build(
+    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 useCurrentUser = () => {
+    const service = UserServiceFactory();
+    const subscribersIds: number[] = [];
+
+    const fetching = ref(false);
+    const fetched = ref<UserDetails | null>(null) as Ref<UserDetails | null>;
+
+    onUnmounted(() => {
+        subscribersIds.forEach(id => service.unsubscribe(id));
+        subscribersIds.length = 0;
+    });
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+        subscribersIds.push(service.subscribe("all", onEntityChanged(fetched)));
+        return readonly(fetched as Ref<UserDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}
+export const useUpdateCurrentUser = () => {
+    const service = UserServiceFactory();
+    const subscribersIds: number[] = [];
+
+    const updating = ref(false);
+    const updated = ref<UserDetails | null>(null) as Ref<UserDetails | null>;
+
+    onUnmounted(() => {
+        subscribersIds.forEach(id => service.unsubscribe(id));
+        subscribersIds.length = 0;
+    });
+
+    const update = async (payload: UpdateUserDTO) => {
+        updating.value = true;
+        try {
+            updated.value = await service.updateCurrent(payload);
+        }
+        finally {
+            updating.value = false;
+        }
+        subscribersIds.push(service.subscribe("all", onEntityChanged(updated)));
+        return readonly(updated as Ref<UserDetails>);
+    }
+
+    return {
+        updating: readonly(updating),
+        update,
+        updated: readonly(updated)
+    }
+}

package/composables/useLanguageCode.ts

@@ -1,8 +1,4 @@
-import { onMounted, provide, ref, watch } from "vue";
-
-import { LANGUAGE_CODE } from "../config/literals";
-
-let initialized = false;
+import { ref, watch } from "vue";
 
 const languageCode = ref<string | null>("fr-FR");
 
@@ -11,18 +7,6 @@ export const useLanguageCode = () => {
         languageCode.value = payload;
     };
 
-    if (!initialized) {
-        provide(LANGUAGE_CODE, languageCode);
-
-        onMounted(() => {
-            if (languageCode.value) {
-                return;
-            }
-        });
-    }
-
-    initialized = true;
-
     const ready = new Promise((resolve) => {
         if (languageCode.value) {
             resolve(languageCode.value);

package/composables/useShared.ts

@@ -0,0 +1,32 @@
+import { onMounted, ref } from "vue";
+import { useLanguageCode, useTimeZone, useTranslationsProvider } from "@dative-gpi/foundation-shared-services";
+
+let called = false;
+
+const ready = ref(false);
+
+export function useShared() {
+    if (called) {
+        return {
+            ready
+        };
+    }
+
+    called = true;
+
+    const { ready: languageCodeReady } = useLanguageCode();
+    const { ready: timeZoneReady } = useTimeZone();
+
+    const { init: initTranslations } = useTranslationsProvider();
+
+    onMounted(async () => {
+        await languageCodeReady
+        await timeZoneReady;
+        await initTranslations();
+        ready.value = true;
+    });
+
+    return {
+        ready
+    };
+}

package/composables/useTimeZone.ts

@@ -1,14 +1,16 @@
-import { onMounted, provide, ref, watch } from "vue";
+import { ref, watch } from "vue";
 
-import { TimeZoneInfos } from "@dative-gpi/foundation-shared-domain/models";
+import { enUS, enGB, fr, it, es, de, Locale } from "date-fns/locale";
+import { format, subDays } from "date-fns";
 
-import { TIME_ZONE } from "../config/literals";
+import { TimeZoneInfos } from "@dative-gpi/foundation-shared-domain/models";
 
-let initialized = false;
+import { useTranslationsProvider } from "./useTranslationsProvider";
+import { useLanguageCode } from "./useLanguageCode";
 
 const timeZone = ref<TimeZoneInfos | null>({
-    id: "UTC",
-    offset: "UTC +03:00:00"
+    id: "Europe/Paris",
+    offset: "UTC +02:00:00"
 });
 
 export const useTimeZone = () => {
@@ -66,23 +68,111 @@ export const useTimeZone = () => {
         return 0;
     };
 
-    if (!initialized) {
-        provide(TIME_ZONE, timeZone);
+    const todayToEpoch = (resetHours: boolean): number => {
+        const today = new Date();
+        if (resetHours) {
+            today.setHours(0, 0, 0, 0);
+        }
+        return today.getTime() + getMachineOffsetMillis() - getUserOffsetMillis();
+    }
 
-        onMounted(() => {
-            if (timeZone.value) {
-                return;
+    const pickerToEpoch = (value: Date): number => {
+        // FSCalendar is always in machine time zone, so we need to convert it to user time zone
+        return value.getTime() + getMachineOffsetMillis() - getUserOffsetMillis();
+    };
+
+    const epochToPicker = (value: number): Date => {
+        // Epoch is always without time zone, so we need to convert it to user time zone
+        const date = new Date(0);
+        date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
+        return date;
+    };
+
+    const epochToPickerHeader = (value: number): { d: number, m: number, y: number } => {
+        const date = new Date(0);
+        date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
+        return { d: date.getDate(), m: date.getMonth(), y: date.getFullYear() };
+    };
+
+    const epochToLongDateFormat = (value: number): string => {
+        if (value == null || !isFinite(value)) {
+            return "";
+        }
+        const date = new Date(0);
+        date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
+        return format(date, "EEEE dd LLLL yyyy", { locale: getLocale() });
+    };
+
+    const epochToLongTimeFormat = (value: number): string => {
+        if (value == null || !isFinite(value)) {
+            return "";
+        }
+        const date = new Date(0);
+        date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
+        return format(date, overrideFormat(date, "EEEE dd LLLL yyyy HH:mm"), { locale: getLocale() })
+    };
+
+    const epochToShortDateFormat = (value: number): string => {
+        if (value == null || !isFinite(value)) {
+            return "";
+        }
+        const date = new Date(0);
+        date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
+        switch (getLocale()) {
+            case enUS: {
+                return format(date, "MM/dd/yyyy", { locale: getLocale() });
             }
-            else {
-                setTimeZone(new TimeZoneInfos({
-                    id: Intl.DateTimeFormat().resolvedOptions().timeZone,
-                    offset: getMachineOffset()
-                }));
+            default: {
+                return format(date, "dd/MM/yyyy", { locale: getLocale() });
             }
-        });
+        }
+    };
+
+    const epochToShortTimeFormat = (value: number): string => {
+        if (value == null || !isFinite(value)) {
+            return "";
+        }
+        const date = new Date(0);
+        date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
+        switch (getLocale()) {
+            case enUS: {
+                return format(date, "MM/dd/yyyy HH:mm", { locale: getLocale() });
+            }
+            default: {
+                return format(date, "dd/MM/yyyy HH:mm", { locale: getLocale() });
+            }
+        }
+    };
+
+    const todayTimeFormat = (): string => {
+        return `'${useTranslationsProvider().$tr("ui.time-zone.today-at", "Today at").replaceAll("'", "''")}' HH:mm:ss`;
+    }
+    
+    const yesterdayTimeFormat = (): string => {
+        return `'${useTranslationsProvider().$tr("ui.time-zone.yesterday-at", "Yesterday at").replaceAll("'", "''")}' HH:mm:ss`;
+    }
+      
+    const overrideFormat = (date: Date, askedFormat: string): string => {
+        let now = new Date();
+        if (date.toDateString() === now.toDateString()) {
+            return todayTimeFormat();
+        }
+        if (date.toDateString() === subDays(now, 1).toDateString()) {
+            return yesterdayTimeFormat();
+        }
+        return askedFormat;
     }
 
-    initialized = true;
+    const getLocale = (): Locale => {
+        switch (useLanguageCode().languageCode.value) {
+            case "fr-FR": return fr;
+            case "es-ES": return es;
+            case "it-IT": return it;
+            case "en-GB": return enGB;
+            case "de-DE": return de;
+            default: return enUS;
+        }
+    }
 
     const ready = new Promise((resolve) => {
         if (timeZone.value) {
@@ -104,6 +194,14 @@ export const useTimeZone = () => {
         getUserOffset,
         getMachineOffset,
         getUserOffsetMillis,
-        getMachineOffsetMillis
+        getMachineOffsetMillis,
+        todayToEpoch,
+        pickerToEpoch,
+        epochToPicker,
+        epochToPickerHeader,
+        epochToLongDateFormat,
+        epochToLongTimeFormat,
+        epochToShortDateFormat,
+        epochToShortTimeFormat
     };
 }

package/composables/useTranslationsProvider.ts

@@ -0,0 +1,28 @@
+import { useLanguageCode, useTranslations } from "@dative-gpi/foundation-shared-services";
+
+let initialized = false;
+
+export const useTranslationsProvider = () => {
+    const $tr = (code: string, defaultValue: string, ...parameters: string[]): string => {
+        let translation = useTranslations().fetched.value.find(t => t.code === code)?.value ?? defaultValue;
+        if (translation && parameters.length) {
+            for (let p of parameters) {
+                translation = translation.replace(`{${parameters.indexOf(p)}}`, p.toString());
+            }
+        }
+        return translation;
+    };
+
+    const init = async () => {
+        if (!initialized) {
+            initialized = true;
+            await useLanguageCode().ready;
+            await useTranslations().fetch(useLanguageCode().languageCode.value!);
+        }
+    }
+
+    return {
+        $tr,
+        init
+    }
+}

package/config/index.ts

@@ -1 +1 @@
-export * from "./literals";
+export * from "./urls";

package/config/urls/applications.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const APPLICATIONS_URL = () => `${GATEWAY_URL()}/applications`;
+export const APPLICATION_CURRENT_URL = () => `${APPLICATIONS_URL()}/curent`;

package/config/urls/authTokens.ts

@@ -0,0 +1,3 @@
+import { GATEWAY_URL } from "./base";
+
+export const AUTH_TOKENS_URL = () => `${GATEWAY_URL()}/auth-tokens`;

package/config/urls/base.ts

@@ -0,0 +1 @@
+export const GATEWAY_URL = () => "/api/shared/v1";

package/config/urls/files.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const FILES_URL = () => `${GATEWAY_URL()}/files`;
+export const FILE_URL = (fileId: string) => `${FILES_URL()}/${encodeURIComponent(fileId)}`;

package/config/urls/frequentlyAskedQuestions.ts

@@ -0,0 +1,3 @@
+import { GATEWAY_URL } from "./base";
+
+export const FREQUENTLY_ASKED_QUESTIONS_URL = () => `${GATEWAY_URL()}/frequently-asked-questions`;

package/config/urls/images.ts

@@ -0,0 +1,12 @@
+import { GATEWAY_URL } from "./base";
+
+export const IMAGES_URL = () => `${GATEWAY_URL()}/images`;
+
+export const IMAGES_RAW_URL = () => `${IMAGES_URL()}/raw`;
+export const IMAGE_RAW_URL = (imageId: string) => `${IMAGES_RAW_URL()}/${encodeURIComponent(imageId)}`;
+
+export const IMAGES_THUMBNAIL_URL = () => `${IMAGES_URL()}/thumbnail`;
+export const IMAGE_THUMBNAIL_URL = (imageId: string) => `${IMAGES_THUMBNAIL_URL()}/${encodeURIComponent(imageId)}`;
+
+export const IMAGES_BLURHASH_URL = () => `${IMAGES_URL()}/blurHash`;
+export const IMAGE_BLURHASH_URL = (imageId: string) => `${IMAGES_BLURHASH_URL()}/${encodeURIComponent(imageId)}`;

package/config/urls/index.ts

@@ -0,0 +1,14 @@
+export * from "./applications";
+export * from "./authTokens";
+export * from "./files";
+export * from "./frequentlyAskedQuestions";
+export * from "./images";
+export * from "./landingPages";
+export * from "./layoutPages";
+export * from "./legalInformations";
+export * from "./organisations";
+export * from "./securitySettings";
+export * from "./timeZones";
+export * from "./translations";
+export * from "./userLegalInformations";
+export * from "./users";

package/config/urls/landingPages.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const LANDING_PAGES_URL = () => `${GATEWAY_URL()}/landing-pages`;
+export const LANDING_PAGE_CURRENT_URL = () => `${LANDING_PAGES_URL()}/current`;

package/config/urls/layoutPages.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const LAYOUT_PAGES_URL = () => `${GATEWAY_URL()}/layout-pages`;
+export const LAYOUT_PAGE_CURRENT_URL = () => `${LAYOUT_PAGES_URL()}/current`;

package/config/urls/legalInformations.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const LEGAL_INFORMATIONS_URL = () => `${GATEWAY_URL()}/legal-informations`;
+export const LEGAL_INFORMATION_CURRENT_URL = () => `${LEGAL_INFORMATIONS_URL()}/current`;

package/config/urls/organisations.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const ORGANISATIONS_URL = () => `${GATEWAY_URL()}/organisations`;
+export const ORGANISATION_URL = (organisationId: string) => `${ORGANISATIONS_URL()}/${encodeURIComponent(organisationId)}`;

package/config/urls/securitySettings.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const SECURITY_SETTINGS_URL = () => `${GATEWAY_URL()}/security-settings`;
+export const SECURITY_SETTING_CURRENT_URL = () => `${SECURITY_SETTINGS_URL()}/current`;

package/config/urls/timeZones.ts

@@ -0,0 +1,3 @@
+import { GATEWAY_URL } from "./base";
+
+export const TIME_ZONES_URL = () => `${GATEWAY_URL()}/time-zones`;

package/config/urls/translations.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const TRANSLATIONS_URL = () => `${GATEWAY_URL()}/translations`;
+export const TRANSLATIONS_LANGUAGE_URL = (languageCode: string) => `${TRANSLATIONS_URL()}/${encodeURIComponent(languageCode)}`;

package/config/urls/userLegalInformations.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const USER_LEGAL_INFORMATIONS_URL = () => `${GATEWAY_URL()}/user-legal-informations`;
+export const USER_LEGAL_INFORMATION_CURRENT_URL = () => `${USER_LEGAL_INFORMATIONS_URL()}/current`;

package/config/urls/users.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const USERS_URL = () => `${GATEWAY_URL()}/users`;
+export const USER_CURRENT_URL = () => `${USERS_URL()}/current`;

package/index.ts

@@ -0,0 +1 @@
+export * from "./composables";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dative-gpi/foundation-shared-services",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -9,11 +9,12 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/bones-ui": "^0.0.50",
-    "@dative-gpi/foundation-shared-domain": "0.0.8",
+    "@dative-gpi/bones-ui": "^0.0.60",
+    "@dative-gpi/foundation-shared-domain": "0.0.10",
     "@microsoft/signalr": "^8.0.0",
+    "date-fns": "^3.2.0",
     "vue": "^3.2.0",
     "vue-router": "^4.2.5"
   },
-  "gitHead": "b3393ad0a66fda249e1b2d3582af86e961553453"
+  "gitHead": "765222a4eb6a5cdd690f64bc0ae3c5415081e0f0"
 }

package/tools/datesTools.ts

@@ -0,0 +1,15 @@
+import { parse } from "date-fns";
+
+const removeArtifacts = (date: string): string => {
+    return date.substring(0, 19) + "Z";
+};
+
+const isoTimeFormat = (timeZone: boolean = false): string => {
+    return `yyyy-MM-dd'T'HH:mm:ss${timeZone ? "X" : ""}`;
+};
+
+export const DatesTools =  {
+    utcToEpoch: (value: string): number => {
+        return parse(removeArtifacts(value), isoTimeFormat(true), new Date()).getTime();
+    }
+};

package/tools/index.ts

@@ -0,0 +1 @@
+export * from "./datesTools";

package/config/literals/index.ts

@@ -1,2 +0,0 @@
-export const TIME_ZONE = "timeZone";
-export const LANGUAGE_CODE = "languageCode";