@vc-shell/framework 1.1.99-alpha.2 → 1.2.1

package/core/composables/useDynamicProperties/index.ts

@@ -68,7 +68,7 @@ export interface IUseDynamicProperties<
   getPropertyValue: (
     property: TProperty,
     locale: string,
-  ) => string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[];
+  ) => string | TPropertyValue[] | boolean | (TPropertyDictionaryItem & { value: string })[];
   setPropertyValue: (data: SetPropertyValueParams<TProperty, TPropertyValue, TPropertyDictionaryItem>) => void;
   loadMeasurements(measureId: string, keyword?: string, locale?: string): Promise<TMeasurement[] | undefined>;
 }
@@ -166,7 +166,7 @@ export const useDynamicProperties = <
 
   // === VALUE GETTERS ===
 
-  function getMultilanguageValue(property: TProperty, locale: string): string | TPropertyValue[] {
+  function getMultilanguageValue(property: TProperty, locale: string): string | TPropertyValue[] | boolean {
     const valueForLocale = property.values?.find((x) => x.languageCode === locale);
 
     if (isMultivalueProperty(property)) {
@@ -188,6 +188,10 @@ export const useDynamicProperties = <
 
         property.values?.push(newValue);
       }
+      // For boolean properties, return false if no value exists
+      if (property.valueType === "Boolean") {
+        return false;
+      }
     }
 
     if (isDictionaryProperty(property)) {
@@ -197,13 +201,19 @@ export const useDynamicProperties = <
     return valueForLocale?.value as string;
   }
 
-  function getSingleLanguageValue(property: TProperty): string | TPropertyValue[] {
+  function getSingleLanguageValue(property: TProperty): string | TPropertyValue[] | boolean {
     if (isMultivalueProperty(property)) {
       return property.values as TPropertyValue[];
     }
 
     const firstValue = property.values?.[0];
-    if (!firstValue) return "";
+    if (!firstValue) {
+      // For boolean properties, return false instead of empty string
+      if (property.valueType === "Boolean") {
+        return false;
+      }
+      return "";
+    }
 
     if (isDictionaryProperty(property)) {
       return firstValue.valueId as string;
@@ -212,7 +222,7 @@ export const useDynamicProperties = <
     return firstValue.value as string;
   }
 
-  function getPropertyValue(property: TProperty, locale: string) {
+  function getPropertyValue(property: TProperty, locale: string): string | TPropertyValue[] | boolean {
     if (isMultilanguageProperty(property)) {
       return getMultilanguageValue(property, locale);
     }
@@ -278,11 +288,7 @@ export const useDynamicProperties = <
     dict: TPropertyDictionaryItem[],
   ): void {
     if (Array.isArray(value)) {
-      handleMultilanguageMultivalueDictionary(
-        property,
-        value as (TPropertyDictionaryItem & { value: string })[],
-        dict,
-      );
+      handleMultilanguageMultivalueDictionary(property, value as (TPropertyDictionaryItem & { value: string })[], dict);
     } else {
       handleMultilanguageSingleValueDictionary(property, value as string, dict);
     }
@@ -470,16 +476,12 @@ export const useDynamicProperties = <
   }
 
   function handleBooleanValue(property: TProperty, value: boolean, initialProp?: TProperty): void {
-    if (initialProp?.values?.length) {
-      property.values = [
-        property.values?.[0]
-          ? Object.assign(property.values[0], { value })
-          : createPropertyValue({ value } as Partial<TPropertyValue>),
-      ];
-    } else if (value) {
-      property.values = [createPropertyValue({ value } as Partial<TPropertyValue>)];
+    // Always create or update the value, even if it's false
+    // This ensures the state is properly reflected in the UI
+    if (property.values?.[0]) {
+      Object.assign(property.values[0], { value });
     } else {
-      property.values = [];
+      property.values = [createPropertyValue({ value } as Partial<TPropertyValue>)];
     }
   }
 

package/core/composables/useNotifications/index.ts

@@ -1,8 +1,6 @@
 import { PushNotification, PushNotificationClient } from "./../../api/platform";
-import { computed, ComputedRef, ref, onUnmounted, inject } from "vue";
+import { computed, ComputedRef, ref, onUnmounted } from "vue";
 import * as _ from "lodash-es";
-import { AuthProviderKey } from "../../../injection-keys";
-import { shouldEnablePlatformFeatures } from "../../providers/auth-provider-utils";
 
 const notificationsClient = new PushNotificationClient();
 
@@ -31,10 +29,6 @@ const subscribers = new Map<
 let subscriberCounter = 0;
 
 export function useNotifications(notifyType?: string | string[]): INotifications {
-  // Check if we're using a custom auth provider
-  const authProvider = inject(AuthProviderKey);
-  const isPlatformProvider = shouldEnablePlatformFeatures(authProvider);
-
   if (notifyType) {
     const types = Array.isArray(notifyType) ? notifyType : [notifyType];
 
@@ -55,12 +49,6 @@ export function useNotifications(notifyType?: string | string[]): INotifications
   }
 
   async function loadFromHistory(take = 10) {
-    // Skip platform API calls for custom authentication providers
-    if (!isPlatformProvider) {
-      console.log("[useNotifications] Skipping loadFromHistory - custom authentication provider detected");
-      return;
-    }
-
     // TODO temporary workaround to get push notifications without base type
     try {
       const result = await fetch("/api/platform/pushnotifications", {
@@ -118,25 +106,6 @@ export function useNotifications(notifyType?: string | string[]): INotifications
   }
 
   async function markAllAsRead() {
-    // Skip platform API calls for custom authentication providers
-    if (!isPlatformProvider) {
-      console.log("[useNotifications] Skipping markAllAsRead - custom authentication provider detected");
-      // Still update local state
-      notifications.value = notifications.value.map((x) => {
-        if (x.isNew) {
-          x.isNew = false;
-        }
-        return x;
-      });
-      pushNotifications.value = pushNotifications.value.map((x) => {
-        if (x.isNew) {
-          x.isNew = false;
-        }
-        return x;
-      });
-      return;
-    }
-
     try {
       notifications.value = notifications.value.map((x) => {
         if (x.isNew) {

package/core/composables/useSettings/index.ts

@@ -1,10 +1,8 @@
 import { useAsync } from "./../useAsync";
 import { useApiClient } from "./../useApiClient";
-import { computed, Ref, ref, ComputedRef, onMounted, inject } from "vue";
+import { computed, Ref, ref, ComputedRef, onMounted } from "vue";
 import { SettingClient } from "./../../api/platform";
 import { useLoading } from "../useLoading";
-import { shouldEnablePlatformFeatures } from "../../providers/auth-provider-utils";
-import { AuthProviderKey } from "../../../injection-keys";
 
 interface IUISetting {
   contrast_logo?: string;
@@ -21,16 +19,13 @@ interface IUseSettings {
 }
 
 export function useSettings(): IUseSettings {
-  // Check if we're using a custom auth provider
-  const authProvider = inject(AuthProviderKey);
-  const isPlatformProvider = shouldEnablePlatformFeatures(authProvider);
   const uiSettings = ref<IUISetting | undefined>();
   const customSettingsApplied = ref(false);
 
   const { getApiClient } = useApiClient(SettingClient);
 
   const { loading, action: getUiCustomizationSettings } = useAsync(async () => {
-    if (customSettingsApplied.value || !isPlatformProvider) return;
+    if (customSettingsApplied.value) return;
 
     const result = await (await getApiClient()).getUICustomizationSetting();
     const settings = await JSON.parse(result.defaultValue ?? null);
@@ -56,7 +51,7 @@ export function useSettings(): IUseSettings {
   }
 
   onMounted(async () => {
-    if (!uiSettings.value && !customSettingsApplied.value && isPlatformProvider) {
+    if (!uiSettings.value && !customSettingsApplied.value) {
       await getUiCustomizationSettings();
     }
   });

package/core/composables/useUser/index.ts

@@ -1,114 +1,211 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { computed, inject, ComputedRef, getCurrentInstance } from "vue";
+import { computed, Ref, ref, ComputedRef } from "vue";
 import {
   UserDetail,
+  SecurityClient,
+  ResetPasswordConfirmRequest,
   SecurityResult,
+  ValidatePasswordResetTokenRequest,
   IdentityResult,
+  ChangePasswordRequest,
   LoginType,
+  LoginRequest,
   SignInResult,
-  IUserDetail,
-  ISecurityResult,
-  ILoginType,
-  IIdentityResult,
 } from "./../../api/platform";
-import { RequestPasswordResult, IAuthProvider } from "./../../types";
+import { RequestPasswordResult } from "./../../types";
 import { createSharedComposable } from "@vueuse/core";
-import { AuthProviderKey } from "../../../injection-keys";
-import { authProviderManager } from "../../providers/auth-provider-manager";
+import { useExternalProvider } from "../../../shared/components/sign-in/useExternalProvider";
 
-/**
- * Interface for the full internal API
- * @deprecated This interface is kept for backward compatibility but will be removed in future versions
- */
+// Interface for the full internal API provided by _createInternalUserLogic
 export interface IUserInternalAPI {
-  user: ComputedRef<IUserDetail | undefined>;
+  user: ComputedRef<UserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
-  loadUser: () => Promise<IUserDetail>;
+  loadUser: () => Promise<UserDetail>;
   signIn: (username: string, password: string) => Promise<SignInResult | { succeeded: boolean; error?: any }>;
   signOut: () => Promise<void>;
   validateToken: (userId: string, token: string) => Promise<boolean>;
-  validatePassword: (password: string) => Promise<IIdentityResult>;
-  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<ISecurityResult>;
+  validatePassword: (password: string) => Promise<IdentityResult>;
+  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<SecurityResult>;
   requestPasswordReset: (loginOrEmail: string) => Promise<RequestPasswordResult>;
-  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<ISecurityResult | undefined>;
-  getLoginType: () => Promise<ILoginType[]>;
+  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult | undefined>;
+  getLoginType: () => Promise<LoginType[]>;
   isAuthenticated: ComputedRef<boolean>;
 }
 
 export interface IAppUserAPI {
-  user: ComputedRef<IUserDetail | undefined>;
+  user: ComputedRef<UserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAuthenticated: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
-  loadUser: () => Promise<IUserDetail>;
+  loadUser: () => Promise<UserDetail>;
   signOut: () => Promise<void>;
 }
 
-/**
- * Get auth provider with fallback to global instance
- * This allows composables to work before Vue app context is available
- * Priority: Vue DI > Global Manager (always has default PlatformAuthProvider)
- */
-function getAuthProvider(): IAuthProvider {
-  // Try to get from Vue DI first (preferred method for components)
-  const instance = getCurrentInstance();
-  if (instance) {
-    const injectedProvider = inject(AuthProviderKey, null);
-    if (injectedProvider) {
-      return injectedProvider;
+const user: Ref<UserDetail | undefined> = ref();
+
+export function _createInternalUserLogic(): IUserInternalAPI {
+  const loading: Ref<boolean> = ref(false);
+
+  const { storage: externalSignInStorage, signOut: externalSignOut } = useExternalProvider();
+
+  const securityClient = new SecurityClient();
+
+  const isAuthenticated = computed(() => user.value?.userName != null);
+
+  async function validateToken(userId: string, token: string): Promise<boolean> {
+    let result = false;
+    try {
+      loading.value = true;
+      result = await securityClient.validatePasswordResetToken(userId, {
+        token,
+      } as ValidatePasswordResetTokenRequest);
+    } catch (e) {
+      //TODO: log error
+    } finally {
+      loading.value = false;
     }
+    return result;
   }
 
-  // Fallback to global provider (always available with default PlatformAuthProvider)
-  return authProviderManager.getProvider();
-}
+  async function validatePassword(password: string): Promise<IdentityResult> {
+    return securityClient.validatePassword(password);
+  }
 
-/**
- * Internal user logic - delegates to auth provider
- * @deprecated This function is kept for backward compatibility but will be removed in future versions
- * Use auth provider directly or useUser/useUserManagement composables
- */
-export function _createInternalUserLogic(): IUserInternalAPI {
-  const authProvider = getAuthProvider();
+  async function resetPasswordByToken(userId: string, password: string, token: string): Promise<SecurityResult> {
+    return securityClient.resetPasswordByToken(userId, {
+      newPassword: password,
+      token,
+    } as ResetPasswordConfirmRequest);
+  }
+
+  async function signIn(
+    username: string,
+    password: string,
+  ): Promise<SignInResult | { succeeded: boolean; error?: any; status?: number }> {
+    console.debug(`[@vc-shell/framework#_createInternalUserLogic:signIn] - Entry point`);
+    try {
+      loading.value = true;
+      const result = await securityClient.login(new LoginRequest({ userName: username, password }));
+      return await securityClient
+        .getCurrentUser()
+        .then((res) => {
+          if (res) {
+            user.value = res;
+            return result;
+          }
+          throw { succeeded: false };
+        })
+        .catch((e) => {
+          throw e;
+        });
+    } catch (e: any) {
+      //TODO: log error
+      console.log(e);
+      return { succeeded: false, error: e.message, status: e.status };
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function signOut(): Promise<void> {
+    console.debug(`[@vc-shell/framework#_createInternalUserLogic:signOut] - Entry point`);
+
+    user.value = undefined;
+
+    if (externalSignInStorage.value?.providerType) {
+      await externalSignOut(externalSignInStorage.value.providerType);
+    } else {
+      securityClient.logout();
+    }
+  }
+
+  async function loadUser(): Promise<UserDetail> {
+    console.debug(`[@vc-shell/framework#_createInternalUserLogic:loadUser] - Entry point`);
+
+    try {
+      loading.value = true;
+      user.value = await securityClient.getCurrentUser();
+      console.log("[_createInternalUserLogic]: an user details has been loaded", user.value);
+    } catch (e: any) {
+      console.error(e);
+    } finally {
+      loading.value = false;
+    }
+
+    return { ...user.value } as UserDetail;
+  }
+
+  async function requestPasswordReset(loginOrEmail: string): Promise<RequestPasswordResult> {
+    try {
+      loading.value = true;
+      await securityClient.requestPasswordReset(loginOrEmail);
+      return { succeeded: true };
+    } catch (e) {
+      //TODO: log error
+      return { succeeded: false, error: e as string };
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function changeUserPassword(oldPassword: string, newPassword: string): Promise<SecurityResult | undefined> {
+    let result;
+
+    try {
+      loading.value = true;
+      const command = new ChangePasswordRequest({
+        oldPassword,
+        newPassword,
+      });
+
+      result = await securityClient.changeCurrentUserPassword(command);
+    } catch (e: any) {
+      return { succeeded: false, errors: [e.message] } as SecurityResult;
+    } finally {
+      loading.value = false;
+    }
+
+    return result;
+  }
+
+  async function getLoginType() {
+    let result: LoginType[] | null = null;
+    try {
+      result = await securityClient.getLoginTypes();
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+
+    return result;
+  }
 
   return {
-    user: authProvider.user,
-    loading: authProvider.loading,
-    isAdministrator: authProvider.isAdministrator,
-    isAuthenticated: authProvider.isAuthenticated,
-    loadUser: authProvider.loadUser.bind(authProvider),
-    signIn: authProvider.signIn.bind(authProvider),
-    signOut: authProvider.signOut.bind(authProvider),
-    validateToken: authProvider.validateToken.bind(authProvider),
-    validatePassword: authProvider.validatePassword.bind(authProvider),
-    resetPasswordByToken: authProvider.resetPasswordByToken.bind(authProvider),
-    requestPasswordReset: authProvider.requestPasswordReset.bind(authProvider),
-    changeUserPassword: authProvider.changeUserPassword.bind(authProvider),
-    getLoginType: authProvider.getLoginType.bind(authProvider),
+    user: computed(() => user.value),
+    loading: computed(() => loading.value),
+    isAdministrator: computed(() => user.value?.isAdministrator),
+    isAuthenticated,
+    loadUser,
+    signIn,
+    signOut,
+    validateToken,
+    validatePassword,
+    resetPasswordByToken,
+    requestPasswordReset,
+    changeUserPassword,
+    getLoginType,
   };
 }
 
 export const useUser = createSharedComposable((): IAppUserAPI => {
-  // Get provider dynamically on each access to ensure correct provider is used
-  // This is important because custom auth providers may be set after composable creation
-
+  const internals = _createInternalUserLogic();
   return {
-    // Computed properties should get provider dynamically
-    get user() {
-      return getAuthProvider().user;
-    },
-    get loading() {
-      return getAuthProvider().loading;
-    },
-    get isAuthenticated() {
-      return getAuthProvider().isAuthenticated;
-    },
-    get isAdministrator() {
-      return getAuthProvider().isAdministrator;
-    },
-    // Methods get provider dynamically on each call
-    loadUser: () => getAuthProvider().loadUser(),
-    signOut: () => getAuthProvider().signOut(),
+    user: internals.user,
+    loading: internals.loading,
+    isAuthenticated: internals.isAuthenticated,
+    isAdministrator: internals.isAdministrator,
+    loadUser: internals.loadUser,
+    signOut: internals.signOut,
   };
 });

package/core/composables/useUserManagement/index.ts

@@ -1,87 +1,45 @@
-import { inject, ComputedRef, getCurrentInstance } from "vue";
+import { computed, ComputedRef } from "vue";
 import { createSharedComposable } from "@vueuse/core";
-import {
-  SecurityResult,
-  IdentityResult,
-  LoginType,
-  UserDetail,
-  SignInResult,
-  IUserDetail,
-  IIdentityResult,
-  ISecurityResult,
-  ILoginType,
-} from "./../../api/platform";
-import { RequestPasswordResult, IAuthProvider } from "./../../types";
-import { AuthProviderKey } from "../../../injection-keys";
-import { authProviderManager } from "../../providers/auth-provider-manager";
+import { _createInternalUserLogic, IUserInternalAPI } from "../useUser"; // Import the internal logic
+import { SecurityResult, IdentityResult, LoginType, UserDetail, SignInResult } from "./../../api/platform";
+import { RequestPasswordResult } from "./../../types";
 
 // Interface for the API exposed by useUserManagement (for framework/admin use)
 export interface IUserManagementAPI {
-  user: ComputedRef<IUserDetail | undefined>;
+  user: ComputedRef<UserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
   isAuthenticated: ComputedRef<boolean>;
   // Methods specific to user management
   validateToken: (userId: string, token: string) => Promise<boolean>;
-  validatePassword: (password: string) => Promise<IIdentityResult>;
-  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<ISecurityResult>;
-  getLoginType: () => Promise<ILoginType[]>;
-  loadUser: () => Promise<IUserDetail>;
+  validatePassword: (password: string) => Promise<IdentityResult>;
+  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<SecurityResult>;
+  getLoginType: () => Promise<LoginType[]>;
+  loadUser: () => Promise<UserDetail>;
   requestPasswordReset: (loginOrEmail: string) => Promise<RequestPasswordResult>;
-  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<ISecurityResult | undefined>;
+  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult | undefined>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   signIn: (username: string, password: string) => Promise<SignInResult | { succeeded: boolean; error?: any }>;
   signOut: () => Promise<void>;
 }
 
-/**
- * Get auth provider with fallback to global instance
- * This allows composables to work before Vue app context is available
- * Priority: Vue DI > Global Manager (always has default PlatformAuthProvider)
- */
-function getAuthProvider(): IAuthProvider {
-  // Try to get from Vue DI first (preferred method for components)
-  const instance = getCurrentInstance();
-  if (instance) {
-    const injectedProvider = inject(AuthProviderKey, null);
-    if (injectedProvider) {
-      return injectedProvider;
-    }
-  }
-
-  // Fallback to global provider (always available with default PlatformAuthProvider)
-  return authProviderManager.getProvider();
-}
-
 export const useUserManagement = createSharedComposable((): IUserManagementAPI => {
-  // Get provider dynamically on each access to ensure correct provider is used
-  // This is important because custom auth providers may be set after composable creation
+  // Utilize the same internal logic instance
+  const internals: IUserInternalAPI = _createInternalUserLogic();
 
   return {
-    // Computed properties should get provider dynamically
-    get user() {
-      return getAuthProvider().user;
-    },
-    get loading() {
-      return getAuthProvider().loading;
-    },
-    get isAdministrator() {
-      return getAuthProvider().isAdministrator;
-    },
-    get isAuthenticated() {
-      return getAuthProvider().isAuthenticated;
-    },
-    // Methods get provider dynamically on each call
-    validateToken: (userId: string, token: string) => getAuthProvider().validateToken(userId, token),
-    validatePassword: (password: string) => getAuthProvider().validatePassword(password),
-    resetPasswordByToken: (userId: string, password: string, token: string) =>
-      getAuthProvider().resetPasswordByToken(userId, password, token),
-    getLoginType: () => getAuthProvider().getLoginType(),
-    loadUser: () => getAuthProvider().loadUser(),
-    requestPasswordReset: (loginOrEmail: string) => getAuthProvider().requestPasswordReset(loginOrEmail),
-    changeUserPassword: (oldPassword: string, newPassword: string) =>
-      getAuthProvider().changeUserPassword(oldPassword, newPassword),
-    signIn: (username: string, password: string) => getAuthProvider().signIn(username, password),
-    signOut: () => getAuthProvider().signOut(),
+    user: internals.user,
+    loading: internals.loading,
+    isAdministrator: internals.isAdministrator,
+    isAuthenticated: internals.isAuthenticated,
+    validateToken: internals.validateToken,
+    validatePassword: internals.validatePassword,
+    resetPasswordByToken: internals.resetPasswordByToken,
+    getLoginType: internals.getLoginType,
+    loadUser: internals.loadUser,
+    requestPasswordReset: internals.requestPasswordReset,
+    changeUserPassword: internals.changeUserPassword,
+    signIn: internals.signIn,
+    signOut: internals.signOut,
   };
 });