@phygitallabs/tapquest-core 4.4.0 → 4.6.0

package/src/modules/achivementWithReward/hooks/achivementPlusRewardModel.ts

@@ -10,7 +10,20 @@ interface GroupRewardData {
   reward_models: EntityRewardModel[][];
 }
 
-function buildMappedAchievements(achievements: Achievement[], groupRewardData: GroupRewardData) {
+export interface AchievementWithRewardModel {
+  id: string;
+  name: string;
+  reward_model: EntityRewardModel | null;
+  subAchievements: {
+    id: string;
+    reward_model: EntityRewardModel | null;
+  }[];
+}
+
+function buildMappedAchievements(
+  achievements: Achievement[],
+  groupRewardData: GroupRewardData
+) {
   if (!groupRewardData?.reward_models) return [];
 
   const rewardModels = groupRewardData.reward_models;
@@ -22,9 +35,9 @@ function buildMappedAchievements(achievements: Achievement[], groupRewardData: G
       achievement.subAchievementIds?.map((subId: string, subIndex: number) => {
         const reward =
           rewardModels[
-          achievementIndex * (achievement.subAchievementIds?.length || 0) +
-          subIndex +
-          1
+            achievementIndex * (achievement.subAchievementIds?.length || 0) +
+              subIndex +
+              1
           ]?.[0] || null;
 
         return {
@@ -42,7 +55,12 @@ function buildMappedAchievements(achievements: Achievement[], groupRewardData: G
   });
 }
 
-const useAchivementPlusRewardModel = ({ campaignId }: UseAchivementPlusRewardModelParams) => {
+const useAchivementPlusRewardModel = ({
+  campaignId,
+}: UseAchivementPlusRewardModelParams): {
+  mappedAchievements: AchievementWithRewardModel[];
+  isLoading: boolean;
+} => {
   const { data: achievements, isLoading: isLoadingAchievements } =
     useManyAchievements(
       {
@@ -59,6 +77,7 @@ const useAchivementPlusRewardModel = ({ campaignId }: UseAchivementPlusRewardMod
       .map((achievement) => achievement.groupRewardId)
       .filter((id): id is string => id !== undefined);
   }, [achievements?.data]);
+
   const {
     mutate: fetchGroupRewardModels,
     data: groupRewardModelsData,
@@ -70,10 +89,14 @@ const useAchivementPlusRewardModel = ({ campaignId }: UseAchivementPlusRewardMod
     }
   }, [groupRewardIds, fetchGroupRewardModels]);
 
-  const mappedAchievements = useMemo(() => {
+  const mappedAchievements: AchievementWithRewardModel[] = useMemo(() => {
     if (!groupRewardModelsData?.data || !achievements?.data) return [];
-    return buildMappedAchievements(achievements.data, groupRewardModelsData.data);
+    return buildMappedAchievements(
+      achievements.data,
+      groupRewardModelsData.data
+    );
   }, [groupRewardModelsData, achievements?.data]);
+
   return {
     mappedAchievements,
     isLoading: isLoadingAchievements || isPendingGroupRewardModels,

package/src/modules/auth/hooks/useGoogleLogin.ts

@@ -2,9 +2,10 @@ import { useRef, useCallback, useEffect } from "react";
 import { useAuth } from "../store/authStore";
 import { tokenStorage } from "@phygitallabs/authentication";
 import { ALLOWED_ORIGINS } from "../constants";
+import { decodeJWTToken } from "../utils/user";
 
 export interface UseGoogleLoginOptions {
-  onSuccess?: () => void;
+  onSuccess?: (userData: any) => void;
   onError?: (error: string) => void;
   onPopupBlocked?: () => void;
   onPopupClosed?: () => void;
@@ -36,9 +37,11 @@ export function useGoogleLogin(options: UseGoogleLoginOptions = {}): UseGoogleLo
               refreshToken: newToken.data.refreshToken,
             });
 
+            const userData = decodeJWTToken(newToken.data.idToken);            
+
             setIsSignedIn(true);
             setIsLoading(false);
-            onSuccess?.();
+            onSuccess?.(userData);
           }
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : "Token refresh failed";

package/src/modules/auth/hooks/useTokenRefresher.ts

@@ -8,17 +8,12 @@ export function useTokenRefresher() {
   const handleRefreshToken = async () => {
     try {
       const isTokenExpired = tokenStorage.isTokenExpired();
+
       if (!isTokenExpired) {
         return;
       }
-      const newToken = await refreshToken();
-
-      if(newToken.data?.idToken && newToken.data?.refreshToken){
-        tokenStorage.setTokens({
-            idToken: newToken.data?.idToken,
-            refreshToken: newToken.data?.refreshToken,
-          });
-      }
+      
+      await refreshToken();
 
     } catch (error) {
       console.error("Failed to refresh token:", error);

package/src/modules/auth/providers/AuthProvider.tsx

@@ -4,7 +4,7 @@ import {
   tokenStorage,
 } from "@phygitallabs/authentication";
 import { useEffect } from "react";
-import { useAuthStore } from "../store/authStore";
+import {useAuthStore} from "../store/authStore";
 import { transformProtoUserData } from "../utils/user";
 import { userService } from "@phygitallabs/api-core";
 import { QueryClient } from "@tanstack/react-query";
@@ -70,8 +70,8 @@ const AuthStateManager = () => {
     let previousIsSignedIn = useAuthStore.getState().isSignedIn;
 
     const unsub = useAuthStore.subscribe(
-      (state: any) => [state.isSignedIn, state.user],
-      async ([isSignedIn]: [any]) => {
+      (state) => [state.isSignedIn, state.user],
+      async ([isSignedIn]) => {
         // Only run when isSignedIn actually changes
         if (isSignedIn === previousIsSignedIn) {
           return;

package/src/modules/auth/services/FirebaseAuthService.ts

@@ -0,0 +1,290 @@
+// Client-side only imports
+let firebaseApp: any;
+let firebaseAuth: any;
+
+// Dynamic imports for client-side only
+const getFirebaseModules = async () => {
+  if (typeof window === 'undefined') {
+    throw new Error('Firebase can only be used in client environment');
+  }
+
+  if (!firebaseApp || !firebaseAuth) {
+    const [
+      { initializeApp, getApps },
+      {
+        getAuth,
+        signInWithEmailAndPassword,
+        createUserWithEmailAndPassword,
+        signInWithPopup,
+        GoogleAuthProvider,
+        signOut,
+        sendPasswordResetEmail,
+        sendEmailVerification,
+        updatePassword,
+        onAuthStateChanged,
+      }
+    ] = await Promise.all([
+      import("firebase/app"),
+      import("firebase/auth")
+    ]);
+
+    firebaseApp = { initializeApp, getApps };
+    firebaseAuth = {
+      getAuth,
+      signInWithEmailAndPassword,
+      createUserWithEmailAndPassword,
+      signInWithPopup,
+      GoogleAuthProvider,
+      signOut,
+      sendPasswordResetEmail,
+      sendEmailVerification,
+      updatePassword,
+      onAuthStateChanged,
+    };
+  }
+
+  return { firebaseApp, firebaseAuth };
+};
+
+import { AuthService, FirebaseConfig, AuthResponse, UserData, SignInProvider } from "../types";
+import { accessTokenKey, refreshTokenKey } from "../constants";
+
+export class FirebaseAuthService implements AuthService {
+  private app: any;
+  private auth: any;
+  private googleProvider: any;
+  private config: FirebaseConfig;
+  private initialized = false;
+
+  constructor(config: FirebaseConfig) {
+    this.config = config;
+    // Initialization will be done lazily in client environment
+  }
+
+  private async ensureInitialized() {
+    if (this.initialized) return;
+
+    const { firebaseApp, firebaseAuth } = await getFirebaseModules();
+
+    // Initialize Firebase app if not already initialized
+    if (!firebaseApp.getApps().length) {
+      this.app = firebaseApp.initializeApp(this.config);
+    } else {
+      this.app = firebaseApp.getApps()[0];
+    }
+
+    this.auth = firebaseAuth.getAuth(this.app);
+    this.googleProvider = new firebaseAuth.GoogleAuthProvider();
+    this.initialized = true;
+  }
+
+  private transformUserData(user: any): UserData {
+    return {
+      id: user.uid,
+      uid: user.uid,
+      userName: user.displayName || "",
+      displayName: user.displayName || "",
+      email: user.email || "",
+      refreshToken: user.refreshToken,
+      accessToken: (user as any).accessToken || "",
+      exp: (user as any).stsTokenManager?.expirationTime || 0,
+      emailVerified: user.emailVerified,
+      avatar: user.photoURL || "/images/default-avatar.jpg",
+      signInProvider: this.getSignInProvider(user),
+      role: undefined,
+      scanStatus: false,
+    };
+  }
+
+  private getSignInProvider(user: any): SignInProvider {
+    const providers = user.providerData.map((p: any) => p.providerId);
+    if (providers.includes("google.com")) return "google.com";
+    return "password";
+  }
+
+  private translateErrorCode(errorCode: string): string {
+    switch (errorCode) {
+      case "auth/invalid-email":
+        return "Email không hợp lệ";
+      case "auth/user-disabled":
+        return "Tài khoản đã bị khóa";
+      case "auth/wrong-password":
+        return "Tài khoản/mật khẩu không đúng";
+      case "auth/user-not-found":
+        return "Tài khoản/mật khẩu không đúng";
+      case "auth/weak-password":
+        return "Weak password! Please use stronger password.";
+      case "auth/email-already-in-use":
+        return "Email đã được sử dụng";
+      case "auth/account-exists-with-different-credential":
+        return "Tài khoản email đã được sử dụng bởi một phương thức đăng nhập khác";
+      case "auth/email-not-verified":
+        return "Email chưa được xác thực";
+      default:
+        return "Đã có lỗi xảy ra";
+    }
+  }
+
+  async signInWithEmailAndPassword(email: string, password: string): Promise<AuthResponse> {
+    try {
+      await this.ensureInitialized();
+      const { firebaseAuth } = await getFirebaseModules();
+      const signInResponse = await firebaseAuth.signInWithEmailAndPassword(this.auth, email, password);
+      const { user } = signInResponse;
+      const data = this.transformUserData(user);
+
+      const { emailVerified } = data;
+      if (!emailVerified) {
+        await this.signOut();
+        localStorage.removeItem("phygital-user-info");
+        localStorage.removeItem(accessTokenKey);
+        localStorage.removeItem(refreshTokenKey);
+        throw new Error("Email is not verified");
+      }
+
+      return {
+        errorCode: "",
+        data,
+      };
+    } catch (err: any) {
+      const errorCode = this.translateErrorCode(err.code);
+      return {
+        errorCode,
+        data: null,
+      };
+    }
+  }
+
+  async signInWithGoogle(): Promise<AuthResponse> {
+    try {
+      await this.ensureInitialized();
+      const { firebaseAuth } = await getFirebaseModules();
+      const signInResponse = await firebaseAuth.signInWithPopup(this.auth, this.googleProvider);
+      const { user } = signInResponse;
+      const data = this.transformUserData(user);
+
+      const { emailVerified } = data;
+      if (!emailVerified) {
+        await this.signOut();
+        throw new Error("Email is not verified");
+      }
+
+      return {
+        errorCode: "",
+        data,
+      };
+    } catch (err: any) {
+      const errorCode = this.translateErrorCode(err.code);
+      return {
+        errorCode,
+        data: null,
+      };
+    }
+  }
+
+  async signUp(email: string, password: string): Promise<AuthResponse> {
+    try {
+      await this.ensureInitialized();
+      const { firebaseAuth } = await getFirebaseModules();
+      const signUpResponse = await firebaseAuth.createUserWithEmailAndPassword(this.auth, email, password);
+      const { user } = signUpResponse;
+      const data = this.transformUserData(user);
+
+      return {
+        errorCode: "",
+        data,
+      };
+    } catch (err: any) {
+      const errorCode = this.translateErrorCode(err.code);
+      return {
+        errorCode,
+        data: null,
+      };
+    }
+  }
+
+  async signOut(): Promise<void> {
+    try {
+      await this.ensureInitialized();
+      const { firebaseAuth } = await getFirebaseModules();
+      await firebaseAuth.signOut(this.auth);
+      // Tracking is now handled through callbacks in the consuming app
+    } catch (err) {
+      console.log("Firebase signOut error:", err);
+    }
+  }
+
+  async sendPasswordResetEmail(email: string): Promise<void> {
+    await this.ensureInitialized();
+    const { firebaseAuth } = await getFirebaseModules();
+    const actionCodeSettings = {
+      url: window.location.origin,
+      handleCodeInApp: true,
+    };
+    await firebaseAuth.sendPasswordResetEmail(this.auth, email, actionCodeSettings);
+  }
+
+  async sendEmailVerification(): Promise<void> {
+    await this.ensureInitialized();
+    const { firebaseAuth } = await getFirebaseModules();
+    if (!this.auth.currentUser) {
+      throw new Error("No current user");
+    }
+    const actionCodeSettings = {
+      url: window.location.origin,
+      handleCodeInApp: true,
+    };
+    await firebaseAuth.sendEmailVerification(this.auth.currentUser, actionCodeSettings);
+  }
+
+  async changePassword(newPassword: string): Promise<void> {
+    await this.ensureInitialized();
+    const { firebaseAuth } = await getFirebaseModules();
+    const user = this.auth.currentUser;
+    if (!user) {
+      throw new Error("No current user");
+    }
+    return firebaseAuth.updatePassword(user, newPassword);
+  }
+
+  onAuthStateChanged(callback: (user: UserData | null) => void): () => void {
+    // For client-side only usage, ensure initialization before setting up auth state listener
+    if (typeof window === 'undefined') {
+      return () => { }; // Return empty unsubscriber for server-side
+    }
+
+    // Set up the listener asynchronously
+    let unsubscriber: (() => void) | null = null;
+
+    this.ensureInitialized().then(async () => {
+      const { firebaseAuth } = await getFirebaseModules();
+      unsubscriber = firebaseAuth.onAuthStateChanged(this.auth, (user: any) => {
+        if (user && user.emailVerified) {
+          const userData = this.transformUserData(user);
+          callback(userData);
+        } else {
+          callback(null);
+        }
+      });
+    });
+
+    // Return unsubscriber function
+    return () => {
+      if (unsubscriber) {
+        unsubscriber();
+      }
+    };
+  }
+
+  getCurrentUser(): UserData | null {
+    if (typeof window === 'undefined' || !this.initialized) {
+      return null; // Return null for server-side or before initialization
+    }
+
+    const user = this.auth.currentUser;
+    if (user && user.emailVerified) {
+      return this.transformUserData(user);
+    }
+    return null;
+  }
+}

package/src/modules/auth/services/authServiceFactory.ts

@@ -0,0 +1,22 @@
+import { FirebaseAuthService } from "./FirebaseAuthService";
+
+interface AuthServiceConfig {
+  firebaseConfig: any;
+}
+
+let authServiceInstance: FirebaseAuthService | null = null;
+
+export const createAuthService = (config: AuthServiceConfig): FirebaseAuthService => {
+  if (!authServiceInstance) {
+    authServiceInstance = new FirebaseAuthService(config.firebaseConfig);
+  }
+  return authServiceInstance;
+};
+
+export const getAuthService = (): FirebaseAuthService | null => {
+  return authServiceInstance;
+};
+
+export const resetAuthService = (): void => {
+  authServiceInstance = null;
+};

package/src/modules/auth/services/index.ts

@@ -0,0 +1,3 @@
+// Export Firebase auth service separately to avoid loading Firebase modules during SSR
+export { FirebaseAuthService } from './FirebaseAuthService';
+export { createAuthService, getAuthService, resetAuthService } from './authServiceFactory';

package/src/modules/auth/store/authStore.ts

@@ -129,7 +129,7 @@ const initialState: AuthState = {
 };
 
 // Create the auth store
-export const useAuthStore :any = create<AuthStore>()(
+export const useAuthStore = create<AuthStore>()(
   devtools(
     persist(
       subscribeWithSelector(
@@ -203,14 +203,14 @@ export const useAuthStore :any = create<AuthStore>()(
                 return response;
               } catch (error: any) {
                 // Check if error has code 7 (email not verified)
-                if (error?.response?.data?.code === 7) {
-                  // Return a special response for email verification needed
-                  return {
-                    data: undefined,
-                    message: "Email verification required",
-                    code: 7,
-                  };
-                }
+                // if (error?.response?.data?.code === 7) {
+                //   // Return a special response for email verification needed
+                //   return {
+                //     data: undefined,
+                //     message: "Email verification required",
+                //     code: 7,
+                //   };
+                // }
 
                 const errorMessage =
                   error instanceof Error ? error.message : "Login failed";
@@ -309,19 +309,18 @@ export const useAuthStore :any = create<AuthStore>()(
                   state.isSignedIn = false;
                   state.error = null;
                 });
+
+                const refreshToken = tokenStorage.getRefreshToken();
                 const isTokenExpired = tokenStorage.isTokenExpired();
-                if (isTokenExpired) {
+
+                if (isTokenExpired || !refreshToken) {
                   tokenStorage.clearTokens();
-                  localStorage.clear();
                   return;
                 }
-                const refreshToken = tokenStorage.getRefreshToken();
-                if (refreshToken) {
-                  await authService.logout({ refreshToken });
-                }
 
-                // Clear tokenStorage first
-                localStorage.clear();
+                await authService.logout({
+                  refreshToken,
+                });
                 tokenStorage.clearTokens();
 
                 // Execute default cleanup functions
@@ -485,6 +484,14 @@ export const useAuthStore :any = create<AuthStore>()(
                 refreshToken:
                   refreshToken ?? tokenStorage.getRefreshToken() ?? "",
               });
+
+              if(refreshTokenResponse.data?.idToken && refreshTokenResponse.data?.refreshToken){
+                tokenStorage.setTokens({
+                    idToken: refreshTokenResponse.data?.idToken,
+                    refreshToken: refreshTokenResponse.data?.refreshToken,
+                  });
+              }
+
               return refreshTokenResponse;
             },
 
@@ -561,12 +568,12 @@ export const useAuthStore :any = create<AuthStore>()(
 );
 
 export const useAuth = () => {
-  const user = useAuthStore((state: any) => state.user);
-  const isSignedIn = useAuthStore((state: any) => state.isSignedIn);
-  const isInitialized = useAuthStore((state: any) => state.isInitialized);
-  const isLoading = useAuthStore((state: any) => state.isLoading);
-  const error = useAuthStore((state: any) => state.error);
-  const actions = useAuthStore((state: any) => state.actions);
+  const user = useAuthStore((state) => state.user);
+  const isSignedIn = useAuthStore((state) => state.isSignedIn);
+  const isInitialized = useAuthStore((state) => state.isInitialized);
+  const isLoading = useAuthStore((state) => state.isLoading);
+  const error = useAuthStore((state) => state.error);
+  const actions = useAuthStore((state) => state.actions);
 
   return {
     user,
@@ -577,4 +584,3 @@ export const useAuth = () => {
     ...actions,
   };
 };
-

package/src/modules/auth/utils/user.ts

@@ -1,6 +1,6 @@
 import { UserData, UserRole, UserType } from "../types/user-data";
 import { UserModel } from "@phygitallabs/api-core";
-import { jwtDecode } from "jwt-decode";
+import jwtDecode from "jwt-decode";
 
 export const transformProtoUserData = (user: UserModel, accessToken: string): UserData => {
   const userData = { ...user } as UserData;
@@ -17,5 +17,15 @@ export const transformProtoUserData = (user: UserModel, accessToken: string): Us
   userData.roles = tokenDecoded?.roles || [UserRole.USER];
   userData.account_type = tokenDecoded?.account_type || UserType.C;
   userData.picture = user.picture || "";
+
   return userData;
 };
+
+export const decodeJWTToken = (token: string): any => {
+  try {
+    return jwtDecode(token);
+  } catch (error) {
+    console.warn("Failed to decode token in decodeJWTToken:", error);
+    return null;
+  }
+};

package/src/modules/data-tracking/hooks/index.ts

@@ -47,7 +47,8 @@ function useDataTracking() {
     const { setUserId, setMetadata } = useSessionReplay();
 
     const trackEvent = (eventName: string, eventData: Record<string, any>, useTools?: ("gtm" | "ga" | "posthog")[]) => {
-
+        console.log("trackEvent ", eventName, eventData);
+        
         useTools = useTools || ["gtm"];
 
         if (useTools.includes("gtm") && typeof window !== "undefined") {

package/src/modules/generate-certificate/hooks/index.ts

@@ -5,6 +5,7 @@ import {
   useCreateCertificate,
   useCreateCertificateAnonymous,
   useCreateCertificateWithMask,
+  useAddFrame,
 } from "@phygitallabs/generate-certificate";
 
 export {
@@ -14,4 +15,5 @@ export {
   useCreateCertificate,
   useCreateCertificateAnonymous,
   useCreateCertificateWithMask,
+  useAddFrame,
 };

package/src/modules/reward/hooks/useRewardService.ts

@@ -3,11 +3,11 @@ export {
   useManyUserRewards,
   useGetUserRewards,
   useClaimUserReward,
-  useListRewardModels,
   useGetRewardModel,
   useCreateRewardModel,
   useUpdateRewardModel,
   useDeleteRewardModel,
+  useListRewardModels,
   useCreateModelGroupReward,
   useClearUserRewardCache,
   useV1ListRewards

package/src/modules/reward/types/requests.ts

@@ -1,5 +1,5 @@
 // Define request types locally since they're not exported from reward package
-import { PaginationRequest, GetManyResponse } from "@phygitallabs/api-core/src/types/pagination";
+import { PaginationRequest, GetManyResponse } from "@phygitallabs/api-core";
 import { EntityRewardModel, UserReward } from "./reward";
 
 // User Rewards API Requests