@dative-gpi/foundation-shared-services 0.0.230 → 0.1.68

package/composables/app/index.ts

@@ -1,4 +1,4 @@
 export * from "./useAppLanguageCode";
 export * from "./useAppLanguages";
 export * from "./useAppTimeZone";
-export * from "./useExtensionJwt";
+export * from "./useAppAuthToken";

package/composables/app/useAppAuthToken.ts

@@ -0,0 +1,17 @@
+import { computed, ref } from "vue";
+
+const authToken = ref<string | undefined>(undefined);
+
+export const useAppAuthToken = () => {
+    const setAppAuthToken = (payload: string) => {
+        authToken.value = payload;
+    };
+
+    const ready = computed(() => authToken.value !== null);
+
+    return {
+        authToken,
+        ready,
+        setAppAuthToken
+    };
+}

package/composables/app/useAppLanguages.ts

@@ -5,7 +5,7 @@ import { type LanguageInfos } from "@dative-gpi/foundation-shared-domain/models"
 const languages = ref<LanguageInfos[] | undefined>(undefined);
 
 export const useAppLanguages = () => {
-    const sepAppLanguages = (payload: LanguageInfos[]) => {
+    const setAppLanguages = (payload: LanguageInfos[]) => {
         languages.value = payload;
     };
 
@@ -14,6 +14,6 @@ export const useAppLanguages = () => {
     return {
         ready,
         languages,
-        sepAppLanguages
+        setAppLanguages
     };
 }

package/composables/app/useAppTimeZone.ts

@@ -1,265 +1,56 @@
-import { format, subDays, addDays, addMilliseconds, parse } from "date-fns";
-import type { Locale } from "date-fns/locale";
-import { enUS, enGB, fr, it, es, de } from "date-fns/locale";
 import { computed, ref } from "vue";
 
-import { useTranslations as useTranslationsProvider } from "@dative-gpi/bones-ui/composables";
-import type { TimeZoneInfos } from "@dative-gpi/foundation-shared-domain/models";
-import { isoTimeFormat } from "@dative-gpi/foundation-shared-domain/tools";
-
-import { useAppLanguageCode } from "./useAppLanguageCode";
-
-const timeZone = ref<TimeZoneInfos | null>(null);
+const timeZone = ref<string | undefined>(undefined);
 
 export const useAppTimeZone = () => {
-  const setAppTimeZone = (payload: TimeZoneInfos) => {
+  const setAppTimeZone = (payload: string) => {
     timeZone.value = payload;
   };
 
-  const getOffsetNumber = (offsetString: string, hours: boolean = false): number => {
-    let offset = 0;
-    switch (offsetString.toLowerCase().replaceAll(" ", "")) {
-      case "utc-11:00:00": offset = -11; break;
-      case "utc-10:00:00": offset = -10; break;
-      case "utc-09:00:00": offset = -9; break;
-      case "utc-08:00:00": offset = -8; break;
-      case "utc-07:00:00": offset = -7; break;
-      case "utc-06:00:00": offset = -6; break;
-      case "utc-05:00:00": offset = -5; break;
-      case "utc-04:00:00": offset = -4; break;
-      case "utc-03:00:00": offset = -3; break;
-      case "utc-02:00:00": offset = -2; break;
-      case "utc-01:00:00": offset = -1; break;
-      case "utc+01:00:00": offset = +1; break;
-      case "utc+02:00:00": offset = +2; break;
-      case "utc+03:00:00": offset = +3; break;
-      case "utc+04:00:00": offset = +4; break;
-      case "utc+05:00:00": offset = +5; break;
-      case "utc+06:00:00": offset = +6; break;
-      case "utc+07:00:00": offset = +7; break;
-      case "utc+08:00:00": offset = +8; break;
-      case "utc+09:00:00": offset = +9; break;
-      case "utc+10:00:00": offset = +10; break;
-      case "utc+11:00:00": offset = +11; break;
-      case "utc+12:00:00": offset = +12; break;
-      case "utc+13:00:00": offset = +13; break;
-      case "utc+14:00:00": offset = +14; break;
-    }
-    return hours ? offset : offset * 60 * 60 * 1000;
-  };
-
-  const userOffset = (): number => {
-    return getOffsetNumber(getUserOffset());
-  };
-
-  const machineOffset = (): number => {
-    return getOffsetNumber(getMachineOffset());
-  };
-
-  const getUserOffset = (): string => {
-    return timeZone?.value?.offset ?? "UTC +00:00:00";
-  };
-
-  const getUserOffsetMillis = (): number => {
-    const offset = timeZone?.value?.offset.slice(3) ?? "";
-    const matchData = offset.match(/([+-])(\d+)(?::(\d+))?/);
-    if (matchData) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const [_, sign, hour, minute] = matchData;
-      return parseInt(sign + "1") * ((hour ? parseInt(hour) : 0) * 60 + (minute ? parseInt(minute) : 0)) * 60 * 1000;
-    }
-    return 0;
-  };
-
-  const getMachineOffset = (): string => {
-    const timeZoneName = Intl.DateTimeFormat("ia", {
-      timeZoneName: "short",
-      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
-    }).formatToParts().find((i) => i.type === "timeZoneName")?.value ?? "";
-
-    const offset = timeZoneName.slice(3);
-    if (!offset) {
-      return "UTC +00:00:00";
-    }
-    const matchData = offset.match(/([+-])(\d+)(?::(\d+))?/);
-    if (matchData) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const [_, sign, hour, minute] = matchData;
-      return `UTC ${sign}${hour.padStart(2, "0")}:${(minute ?? "").padStart(2, "0")}:00`;
-    }
-    return "UTC +00:00:00";
-  };
-
-  const getMachineOffsetMillis = (): number => {
-    const timeZoneName = Intl.DateTimeFormat("ia", {
-      timeZoneName: "short",
-      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
-    }).formatToParts().find((i) => i.type === "timeZoneName")?.value ?? "";
-
-    const offset = timeZoneName.slice(3);
-    if (!offset) {
-      return 0;
-    }
-    const matchData = offset.match(/([+-])(\d+)(?::(\d+))?/);
-    if (matchData) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const [_, sign, hour, minute] = matchData;
-      return parseInt(sign + "1") * ((hour ? parseInt(hour) : 0) * 60 + (minute ? parseInt(minute) : 0)) * 60 * 1000;
-    }
-    return 0;
-  };
-
-  const todayToEpoch = (resetHours: boolean): number => {
-    const today = new Date();
-    if (resetHours) {
-      today.setHours(0, 0, 0, 0);
-    }
-    return today.getTime() + getMachineOffsetMillis() - getUserOffsetMillis();
-  };
-
-  const pickerToEpoch = (value: Date | null | undefined): number => {
-    if (value != null) {
-      // FSCalendar is always in machine time zone, so we need to convert it to user time zone
-      return value.getTime() + getMachineOffsetMillis() - getUserOffsetMillis();
-    }
-    return 0;
-  };
-
-  const epochToPicker = (value: number | null | undefined): Date => {
-    const date = new Date(0);
-    if (value != null) {
-      // Epoch is always without time zone, so we need to convert it to user time zone
-      date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
-    }
-    return date;
-  };
-
-  const epochToPickerHeader = (value: number): { d: number, m: number, y: number } => {
-    const date = new Date(0);
-    if (value != null) {
-      date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
-    }
-    return { d: date.getDate(), m: date.getMonth(), y: date.getFullYear() };
-  };
-
-  const epochToLongDateFormat = (value: number | null | undefined): 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 | null | undefined): 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 | null | undefined): 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() });
-      }
-      default: {
-        return format(date, "dd/MM/yyyy", { locale: getLocale() });
-      }
-    }
-  };
-
-  const epochToTimeOnlyFormat = (value: number | null | undefined): string => {
-    if (value == null || !isFinite(value)) {
-      return "";
-    }
-    const date = new Date(0);
-    date.setUTCMilliseconds(value - getMachineOffsetMillis() + getUserOffsetMillis());
-    return format(date, "HH:mm:ss", { locale: getLocale() });
-  };
-
-  const epochToShortTimeFormat = (value: number | null | undefined): 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 getUserFormatter = (): Intl.DateTimeFormat => {
+    return new Intl.DateTimeFormat(undefined, {
+      timeZone: timeZone.value || Intl.DateTimeFormat().resolvedOptions().timeZone,
+      timeZoneName: "longOffset"
+    });
+  }
 
-  const todayTimeFormat = (): string => {
-    return `'${useTranslationsProvider().$tr("ui.time-zone.today-at", "Today at").replace(/'/g, "''")}' HH:mm:ss`;
-  };
+  const getMachineFormatter = (): Intl.DateTimeFormat => {
+    return new Intl.DateTimeFormat(undefined, {
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      timeZoneName: "longOffset"
+    });
+  }
 
-  const yesterdayTimeFormat = (): string => {
-    return `'${useTranslationsProvider().$tr("ui.time-zone.yesterday-at", "Yesterday at").replace(/'/g, "''")}' HH:mm:ss`;
-  };
+  const getUserOffsetName = (): string => {
+    const formatter = getUserFormatter();
+    const currentDate = formatter.formatToParts(new Date());
+    const timeZoneName = currentDate.find((part) => part.type === "timeZoneName")?.value || "UTC+00:00";
+    return timeZoneName
+  }
 
-  const overrideFormat = (date: Date, askedFormat: string): string => {
-    const now = new Date();
-    if (date.toDateString() === now.toDateString()) {
-      return todayTimeFormat();
-    }
-    if (date.toDateString() === subDays(now, 1).toDateString()) {
-      return yesterdayTimeFormat();
-    }
-    return askedFormat;
-  };
+  const getUserOffset = (): number => {
+    const timeZoneName = getUserOffsetName();
+    const [hours, minutes] = timeZoneName.slice(3).split(':');
 
-  const getLocale = (): Locale => {
-    switch (useAppLanguageCode().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;
-    }
+    return (parseInt(hours) * 60 + parseInt(minutes)) * 60 * 1000;
   };
 
-  const parseForPicker = (value: string, dateFormat: string = isoTimeFormat()): number | null => {
-    let date = parse(value!, dateFormat, new Date());
-    date = addMilliseconds(date, userOffset());
-    if (!isFinite(date.getTime())) {
-      return null;
-    }
-    return date.getTime();
+  const getMachineOffsetName = (): string => {
+    const formatter = getMachineFormatter();
+    const currentDate = formatter.formatToParts(new Date());
+    const timeZoneName = currentDate.find((part) => part.type === "timeZoneName")?.value || "UTC+00:00";
+    return timeZoneName;
   };
 
-  const formatCurrentForPicker = (daysOffset: number = -1): string => {
-    let date = new Date();
-    date.setSeconds(0, 0);
-    date = addMilliseconds(addDays(date, daysOffset), -machineOffset());
-    return format(date, isoTimeFormat());
-  };
+  const getMachineOffset = (): number => {
+    const timeZoneName = getMachineOffsetName();
+    const [hours, minutes] = timeZoneName.slice(3).split(':');
 
-  const formatFromPicker = (date: number | null): string => {
-    if (date != null) {
-      const epoch = date - machineOffset() + (machineOffset() - userOffset());
-      return format(epoch, isoTimeFormat());
-    }
-    return "";
-  };
+    return (parseInt(hours) * 60 + parseInt(minutes)) * 60 * 1000;
+  }
 
-  const formatEpochToVariable = (epoch: number | undefined): string => {
-    if (epoch == null || !isFinite(epoch)) {
-      return "";
-    }
-    return format(epoch - machineOffset(), isoTimeFormat());
+  const getOffsetDifference = (): number => {
+    return getUserOffset() - getMachineOffset();
   };
 
   const ready = computed(() => timeZone.value !== null);
@@ -269,21 +60,9 @@ export const useAppTimeZone = () => {
     timeZone,
     setAppTimeZone,
     getUserOffset,
+    getUserOffsetName,
     getMachineOffset,
-    getUserOffsetMillis,
-    getMachineOffsetMillis,
-    todayToEpoch,
-    pickerToEpoch,
-    epochToPicker,
-    epochToPickerHeader,
-    epochToLongDateFormat,
-    epochToLongTimeFormat,
-    epochToShortDateFormat,
-    epochToShortTimeFormat,
-    epochToTimeOnlyFormat,
-    parseForPicker,
-    formatCurrentForPicker,
-    formatFromPicker,
-    formatEpochToVariable
+    getMachineOffsetName,
+    getOffsetDifference,
   };
 }

package/composables/index.ts

@@ -2,4 +2,5 @@ export * from "./services";
 export * from "./app";
 
 export * from "./useFiles";
-export * from "./useFoundationShared";
+export * from "./useFoundationShared";
+export * from "./useDateFormat";

package/composables/services/index.ts

@@ -1,6 +1,7 @@
 export * from "./useAuthTokens";
 export * from "./useImages";
 export * from "./useLanguages";
+export * from "./useNotifications";
 export * from "./useOrganisations";
 export * from "./useTerminals";
 export * from "./useTimeZones";

package/composables/services/useImages.ts

@@ -1,11 +1,12 @@
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import type { BlurHashDTO } from "@dative-gpi/foundation-shared-domain/models";
-import { BlurHash } from "@dative-gpi/foundation-shared-domain/models";
+import type { ImageDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
+import { ImageDetails } from "@dative-gpi/foundation-shared-domain/models";
 
-import { IMAGE_BLURHASH_URL } from "../../config/urls";
+import { IMAGE_URL } from "../../config/urls";
 
-const ImageServiceFactory = {
-    ...ServiceFactory.addCustom("getBlurHash", (axios, imageId: string) => axios.get(IMAGE_BLURHASH_URL(imageId)), (dto: BlurHashDTO) => new BlurHash(dto))
-};
+const ImageServiceFactory = new ServiceFactory<ImageDetailsDTO, ImageDetails>("image", ImageDetails).create(factory => factory.build(
+    factory.addGet(IMAGE_URL),
+    factory.addNotify()
+));
 
-export const useImageBlurHash = ComposableFactory.custom(ImageServiceFactory.getBlurHash);
+export const useImage = ComposableFactory.get(ImageServiceFactory);

package/composables/services/useNotifications.ts

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

package/composables/useDateFormat.ts

@@ -0,0 +1,220 @@
+import { addMilliseconds, format, parse, subDays } from "date-fns";
+
+import { useTranslations as useTranslationsProvider } from "@dative-gpi/bones-ui/composables";
+import { ISO_FORMAT, OPTIONS } from "@dative-gpi/foundation-shared-domain/tools";
+
+import { useAppLanguageCode, useAppTimeZone } from "./app/";
+
+export const useDateFormat = () => {
+  const { $tr } = useTranslationsProvider();
+
+  const { languageCode } = useAppLanguageCode();
+  const { timeZone, getOffsetDifference, getMachineOffset, getUserOffset } = useAppTimeZone();
+
+  const isEpochToday = (value: number | null | undefined): boolean => {
+    if (value == null || !isFinite(value)) {
+      return false;
+    }
+    const date = new Date(value);
+    const now = new Date();
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.shortDate, timeZone: timeZone.value }) 
+      === now.toLocaleString(languageCode.value, { ...OPTIONS.shortDate, timeZone: timeZone.value });
+  }
+
+  const isEpochYesterday = (value: number | null | undefined): boolean => {
+    if (value == null || !isFinite(value)) {
+      return false;
+    }
+    const date = new Date(value);
+    const now = new Date();
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.shortDate, timeZone: timeZone.value }) 
+      === subDays(now, 1).toLocaleString(languageCode.value, { ...OPTIONS.shortDate, timeZone: timeZone.value });
+  }
+
+  const dayToMillisecond = (value: number): number => {
+    return value * 24 * 60 * 60 * 1000
+  }
+
+  const epochToDayMonthLongOnly = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.dayMonthLongOnly, timeZone: timeZone.value });
+  }
+
+  const epochToShortDateFormat = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.shortDate, timeZone: timeZone.value });
+  };
+
+  const epochToLongDateFormat = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    if (isEpochToday(value)) {
+      return $tr("ui.time-zone.today", "Today");
+    }
+    if (isEpochYesterday(value)) {
+      return $tr("ui.time-zone.yesterday", "Yesterday");
+    }
+    const dateString = date.toLocaleString(languageCode.value, { ...OPTIONS.longDate, timeZone: timeZone.value });
+    return dateString[0].toLocaleUpperCase() + dateString.slice(1);
+  };
+
+  const epochToShortTimeFormat = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.shortTime, timeZone: timeZone.value });
+  };
+
+  const epochToLocalDayStart = (value: number | null | undefined): number => {
+    if (value == null || !isFinite(value)) {
+      return 0;
+    }
+    const date = new Date(value);
+    return date.setHours(0, 0, 0, 0);
+  }
+
+  const epochToLocalDayEnd = (value: number | null | undefined): number => {
+    if (value == null || !isFinite(value)) {
+      return 0;
+    }
+    const date = new Date(value);
+    return date.setHours(23, 59, 59, 999);
+  }
+
+  const epochToLongTimeFormat = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    if (isEpochToday(value)) {
+      return `${$tr("ui.time-zone.today-at", "Today at")} ${date.toLocaleString(languageCode.value, { ...OPTIONS.time, timeZone: timeZone.value })}`;
+    }
+    if (isEpochYesterday(value)) {
+      return `${$tr("ui.time-zone.yesterday-at", "Yesterday at")} ${date.toLocaleString(languageCode.value, { ...OPTIONS.time, timeZone: timeZone.value })}`;
+    }
+    const dateString = date.toLocaleString(languageCode.value, { ...OPTIONS.longTime, timeZone: timeZone.value });
+    return dateString[0].toLocaleUpperCase() + dateString.slice(1);
+  };
+
+  const epochToMonthYearOnlyFormat = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.monthYearOnly, timeZone: timeZone.value });
+  }
+
+  const epochToTimeOnlyFormat = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.time, timeZone: timeZone.value });
+  };
+
+  const epochToShortTimeOnlyFormat = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.shortTimeOnly, timeZone: timeZone.value });
+  }
+
+  const epochToWeekNumber = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    date.setHours(0, 0, 0, 0);
+    date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
+    const week1 = new Date(date.getFullYear(), 0, 4);
+    return `${1 + Math.round(((date.getTime() - week1.getTime()) / 86400000 - 3 + (week1.getDay() + 6) % 7) / 7)}`;
+  }
+
+  const todayToEpoch = (): number => {
+    return new Date().getTime() + getOffsetDifference();
+  };
+
+  const pickerToEpoch = (value: Date | null | undefined): number => {
+    if (value != null) {
+      return value.getTime() - getOffsetDifference();
+    }
+    return 0;
+  };
+
+  const epochToPicker = (value: number | null | undefined): Date => {
+    if (value != null) {
+      return new Date(value + getOffsetDifference());
+    }
+    return new Date(0);
+  };
+
+  const epochToPickerHeader = (value: number): { d: number, m: number, y: number } => {
+    const date = epochToPicker(value);
+    return { d: date.getDate(), m: date.getMonth(), y: date.getFullYear() };
+  };
+
+  const millisecondToDay = (value: number): number => {
+    return value / 1000 / 60 / 60 / 24;
+  }
+
+  const todayToPicker = (): string => {
+    const date = addMilliseconds(new Date(), -getMachineOffset());
+    date.setSeconds(0, 0);
+    return format(date, ISO_FORMAT);
+  };
+
+  const yesterdayToPicker = (): string => {
+    const date = addMilliseconds(subDays(new Date(), 1), -getMachineOffset());
+    date.setSeconds(0, 0);
+    return format(date, ISO_FORMAT);
+  };
+
+  const parseForPicker = (value: string, dateFormat: string = ISO_FORMAT): number | null => {
+    const date = addMilliseconds(parse(value, dateFormat, new Date()), getUserOffset());
+    if (!isFinite(date.getTime())) {
+      return null;
+    }
+    return date.getTime();
+  };
+
+  const epochToISO = (date: number | null): string => {
+    if (date != null) {
+      return format(date - getMachineOffset(), ISO_FORMAT);
+    }
+    return "";
+  };
+
+  return {
+    todayToEpoch,
+    pickerToEpoch,
+    dayToMillisecond,
+    epochToDayMonthLongOnly,
+    epochToPicker,
+    epochToPickerHeader,
+    epochToLocalDayStart,
+    epochToLocalDayEnd,
+    epochToLongDateFormat,
+    epochToLongTimeFormat,
+    epochToMonthYearOnlyFormat,
+    epochToShortDateFormat,
+    epochToShortTimeFormat,
+    epochToShortTimeOnlyFormat,
+    epochToTimeOnlyFormat,
+    epochToWeekNumber,
+    millisecondToDay,
+    parseForPicker,
+    todayToPicker,
+    yesterdayToPicker,
+    epochToISO
+  };
+}

package/config/index.ts

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

package/config/literals/hubs.ts

@@ -0,0 +1,16 @@
+export const SUBSCRIBE = "Subscribe";
+export const UNSUBSCRIBE = "Unsubscribe";
+
+export const UPDATE_DEVICE_STATUS = "UpdateDeviceStatus";
+
+export const UPDATE_DEVICE_CONNECTIVITY = "UpdateDeviceConnectivity";
+
+export const CREATE_ALERT = "CreateAlert";
+export const UPDATE_ALERT = "UpdateAlert";
+export const REMOVE_ALERT = "RemoveAlert";
+
+export const CREATE_CONNECTIVITY_ALERT = "CreateConnectivityAlert";
+export const UPDATE_CONNECTIVITY_ALERT = "UpdateConnectivityAlert";
+export const REMOVE_CONNECTIVITY_ALERT = "RemoveConnectivityAlert";
+
+export const CREATE_NOTIFICATION = "CreateNotification";

package/config/literals/index.ts

@@ -0,0 +1 @@
+export * as HUBS from "./hubs";

package/config/urls/base.ts

@@ -1 +1,3 @@
-export const GATEWAY_URL = () => "/api/foundation/shared/v1";
+export const GATEWAY_URL = () => "/api/foundation/shared/v1";
+
+export const HUBS_URL = () => "/api/foundation/hubs/v1";

package/config/urls/images.ts

@@ -2,12 +2,18 @@ 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 IMAGE_RAW_EXTENSION_URL = (imageId: string, jwt: string) => `${IMAGE_RAW_URL(imageId)}?access_token=${jwt}`;
-
-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)}`;
+export const IMAGE_URL = (imageId: string) => `${IMAGES_URL()}/${encodeURIComponent(imageId)}`;
+export const IMAGE_RAW_URL = (imageId: string, accessToken?: string) => {
+  let url = `${IMAGE_URL(imageId)}/raw`;
+  if (accessToken) {
+    url += `?access_token=${encodeURIComponent(accessToken)}`;
+  }
+  return url;
+};
+export const IMAGE_THUMBNAIL_URL = (imageId: string, accessToken?: string) => {
+  let url = `${IMAGE_URL(imageId)}/thumbnail`;
+  if (accessToken) {
+    url += `?access_token=${encodeURIComponent(accessToken)}`;
+  }
+  return url;
+};

package/config/urls/index.ts

@@ -2,6 +2,7 @@ export * from "./authTokens";
 export * from "./files";
 export * from "./images";
 export * from "./languages";
+export * from "./notifications";
 export * from "./organisations";
 export * from "./terminals";
 export * from "./timeZones";

package/config/urls/notifications.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dative-gpi/foundation-shared-services",
   "sideEffects": false,
-  "version": "0.0.230",
+  "version": "0.1.68",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,7 +10,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/foundation-shared-domain": "0.0.230"
+    "@dative-gpi/foundation-shared-domain": "0.1.68"
   },
   "peerDependencies": {
     "@dative-gpi/bones-ui": "^0.0.75",
@@ -18,5 +18,5 @@
     "vue": "^3.4.29",
     "vue-router": "^4.3.0"
   },
-  "gitHead": "93365f65d39d6c9cc3821ffb48cba187200deaf9"
+  "gitHead": "fa2ed7031088f422751fc1d939f2fbe168ae0596"
 }

package/tools/hubFactory.ts

@@ -28,7 +28,12 @@ export class HubFactory {
                     })
                 }
                 if (connection.state !== signalR.HubConnectionState.Connected) {
-                    await connection.start();
+                    try {
+                        await connection.start();
+                    }
+                    catch {
+                        return;
+                    }
                 }
                 if (!subscribed) {
                     await init(connection);

package/tools/index.ts

@@ -1 +1,2 @@
-export * from "./hubFactory";
+export * from "./hubFactory";
+export * from "./translate";

package/tools/translate.ts

@@ -0,0 +1,17 @@
+import { useAppLanguageCode  } from "../composables";
+
+export const translate = <TTranslation extends { languageCode: string }>(
+    translations: TTranslation[], 
+    accessor: (item: TTranslation) => string, 
+    defaultValue: string): string => {
+
+    const { languageCode } = useAppLanguageCode();
+
+    if(!languageCode.value) {
+        return defaultValue;
+    }
+
+    const translation = translations.find(t => t.languageCode === languageCode.value);
+
+    return translation ? accessor(translation) : defaultValue;
+}

package/composables/app/useExtensionJwt.ts

@@ -1,17 +0,0 @@
-import { computed, ref } from "vue";
-
-const jwt = ref<string | undefined>(undefined);
-
-export const useExtensionJwt = () => {
-    const setExtensionJwt = (payload: string) => {
-        jwt.value = payload;
-    };
-
-    const ready = computed(() => jwt.value !== null);
-
-    return {
-        jwt,
-        ready,
-        setExtensionJwt
-    };
-}