@phygitallabs/tapquest-core 2.0.0

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/authSlice.ts

@@ -0,0 +1,137 @@
+import { createSlice, PayloadAction } from "@reduxjs/toolkit";
+import { UserData, UserRole } from "../types";
+import {
+  setUserInfo,
+  removeUserInfo,
+  getUserInfo,
+  setAccessToken,
+  setRefreshToken,
+  removeAccessToken,
+  removeRefreshToken,
+  getAccessToken,
+} from "../helpers";
+
+const defaultUser: UserData = {
+  uid: "",
+  id: "",
+  userName: "",
+  displayName: "",
+  avatar: "/images/default-avatar.jpg",
+  email: "",
+  exp: 0,
+  emailVerified: false,
+  refreshToken: "",
+  accessToken: "",
+  role: UserRole.NULL,
+  scanStatus: false,
+};
+
+export interface AuthState {
+  user: UserData;
+  isSignedIn: boolean;
+  pending: boolean;
+}
+
+const initialState: AuthState = {
+  user: defaultUser,
+  isSignedIn: false,
+  pending: true,
+};
+
+export const authSlice = createSlice<
+  AuthState,
+  {
+    signIn: (state: AuthState, action: PayloadAction<UserData>) => void;
+    signOut: (state: AuthState) => void;
+    updateScanStatus: (state: AuthState, action: PayloadAction<boolean>) => void;
+    refreshUser: (state: AuthState, action: PayloadAction<UserData>) => void;
+    setPending: (state: AuthState, action: PayloadAction<boolean>) => void;
+    initializeFromStorage: (state: AuthState) => void;
+  },
+  'auth'
+>({
+  name: "auth",
+  initialState,
+  reducers: {
+    signIn: (state, action: PayloadAction<UserData>) => {
+      const userData = action.payload;
+      state.user = userData;
+      state.isSignedIn = true;
+      state.pending = false;
+
+      // Store in localStorage for persistence
+      setUserInfo(userData);
+      setAccessToken(userData.accessToken);
+      setRefreshToken(userData.refreshToken);
+    },
+    signOut: (state) => {
+      state.user = defaultUser;
+      state.isSignedIn = false;
+      state.pending = false;
+
+      // Clear localStorage
+      removeUserInfo();
+      removeAccessToken();
+      removeRefreshToken();
+    },
+    updateScanStatus: (state, action: PayloadAction<boolean>) => {
+      state.user.scanStatus = action.payload;
+
+      // Update localStorage
+      setUserInfo(state.user);
+    },
+    refreshUser: (state, action: PayloadAction<UserData>) => {
+      const userData = action.payload;
+      if (userData) {
+        state.user = userData;
+        state.isSignedIn = true;
+        state.pending = false;
+
+        // Update localStorage
+        setUserInfo(userData);
+        setAccessToken(userData.accessToken);
+        setRefreshToken(userData.refreshToken);
+      }
+    },
+    setPending: (state, action: PayloadAction<boolean>) => {
+      state.pending = action.payload;
+    },
+    initializeFromStorage: (state) => {
+      const storedUser = getUserInfo();
+      const accessToken = getAccessToken();
+
+      if (storedUser && accessToken) {
+        state.user = storedUser;
+        state.isSignedIn = true;
+      }
+      state.pending = false;
+    },
+  },
+});
+
+export const {
+  signIn,
+  signOut,
+  updateScanStatus,
+  refreshUser,
+  setPending,
+  initializeFromStorage,
+} = authSlice.actions;
+
+// Selectors
+export const selectAuth = (state: any) => state.auth;
+export const selectUser = (state: any) => state.auth.user;
+export const selectUserUId = (state: any) =>
+  state.auth.user.uid || state.auth.user.id;
+export const selectUserAccesstoken = (state: any) =>
+  state.auth.user.accessToken;
+export const selectUserEmail = (state: any) => state.auth.user.email;
+export const selectUsername = (state: any) => state.auth.user.userName;
+export const selectSignInProvider = (state: any) =>
+  state.auth.user.signInProvider;
+export const selectUserScanStatus = (state: any) =>
+  state.auth.user.scanStatus;
+export const selectIsSignedIn = (state: any) => state.auth.isSignedIn;
+export const selectIsLoading = (state: any) => state.auth.pending;
+
+export default authSlice.reducer;

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

@@ -0,0 +1,109 @@
+export type SignInProvider = "password" | "google.com";
+
+export enum UserRole {
+  NULL = "NULL",
+  SUPERADMIN = "SUPER_ADMIN",
+  ORGADMIN = "ORG_ADMIN",
+}
+
+export type UserData = {
+  uid: string;
+  id: string;
+  userName: string;
+  displayName?: string;
+  avatar: string;
+  exp: number;
+  email: string;
+  emailVerified: boolean;
+  accessToken: string;
+  refreshToken: string;
+  signInProvider?: SignInProvider;
+  role?: UserRole;
+  scanStatus?: boolean;
+};
+
+export interface UpdateUser {
+  full_name: string;
+}
+
+export interface AuthResponse {
+  errorCode: string;
+  data: UserData | null;
+}
+
+export interface AuthState {
+  user: UserData;
+  isSignedIn: boolean;
+  pending: boolean;
+}
+
+// Auth service interface - allows for Firebase or other providers
+export interface AuthService {
+  // Authentication methods
+  signInWithEmailAndPassword(email: string, password: string): Promise<AuthResponse>;
+  signInWithGoogle(): Promise<AuthResponse>;
+  signUp(email: string, password: string): Promise<AuthResponse>;
+  signOut(): Promise<void>;
+
+  // Password management
+  sendPasswordResetEmail(email: string): Promise<void>;
+  sendEmailVerification(): Promise<void>;
+  changePassword(newPassword: string): Promise<void>;
+
+  // Auth state monitoring
+  onAuthStateChanged(callback: (user: UserData | null) => void): () => void;
+
+  // Current user
+  getCurrentUser(): UserData | null;
+}
+
+// Auth callbacks interface for external integrations (analytics, tracking, etc.)
+export interface AuthCallbacks {
+  onUserIdentify?: (userInfo: { email: string; name?: string; avatar?: string; uid?: string }) => void;
+  onTrackingReset?: () => void;
+  onSignInSuccess?: (userData: UserData) => void;
+  onSignInError?: (error: string) => void;
+  onSignOutSuccess?: () => void;
+  onSignUpSuccess?: (userData: UserData) => void;
+  onSignUpError?: (error: string) => void;
+}
+
+// Hook return types
+export interface UseAuthReturn {
+  // User state
+  user: UserData;
+  isSignedIn: boolean;
+  isLoading: boolean;
+
+  // Auth actions
+  signIn: (email: string, password: string) => Promise<AuthResponse>;
+  signInWithGoogle: () => Promise<AuthResponse>;
+  signUp: (email: string, password: string) => Promise<AuthResponse>;
+  signOut: () => Promise<void>;
+
+  // Password actions
+  forgotPassword: (email: string) => Promise<void>;
+  sendEmailVerification: () => Promise<void>;
+  changePassword: (newPassword: string) => Promise<void>;
+
+  // User management
+  updateScanStatus: (status: boolean) => void;
+  refreshUser: (userData: UserData) => void;
+}
+
+// Provider props
+export interface AuthProviderProps {
+  children: React.ReactNode;
+  authService: AuthService;
+  authCallbacks?: AuthCallbacks;
+}
+
+export interface FirebaseConfig {
+  apiKey: string;
+  authDomain: string;
+  projectId: string;
+  storageBucket: string;
+  messagingSenderId: string;
+  appId: string;
+  measurementId: string;
+}

package/src/modules/campaign/hooks/index.ts

@@ -0,0 +1,6 @@
+// Export campaign service hooks
+export {
+  useCampaignDetail,
+  useUserCampaignAction,
+  useOneUserCampaign,
+} from "./useCampaignService";

package/src/modules/campaign/hooks/useCampaignService.ts

@@ -0,0 +1,7 @@
+// Re-export from @phygitallabs/api-core package
+export {
+  useOneCampaign as useCampaignDetail,
+  useUserCampaignAction,
+  useOneUserCampaign,
+
+} from "@phygitallabs/api-core";

package/src/modules/campaign/index.tsx

@@ -0,0 +1,7 @@
+// Export campaign functionality
+export {
+  useCampaignDetail,
+  useUserCampaignAction,
+  useOneUserCampaign
+} from "./hooks";
+export * from "./types";

package/src/modules/campaign/types/campaign.ts

@@ -0,0 +1,51 @@
+// Re-export from @phygitallabs/api-core package
+export type {
+  CampaignModel,
+  UserCampaignModel,
+  MissionWithProgress,
+  TaskWithProgress,
+  UserCampaignMission,
+  Mission,
+  MissionProgress,
+  TaskProgress,
+} from "@phygitallabs/api-core";
+
+export enum TaskType {
+  CHECK_IN = "check_in",
+  CREATE_MEMORY = "create_memory",
+  FILL_FORM = "fill_form",
+  SHARE = "share",
+}
+
+// Define other types locally since they're not exported from api-core package
+export interface CampaignByProjectIdModel {
+  id: string;
+  certificate_index?: number;
+  completed_checkin_rule?: number;
+  completed_device_uids?: string[];
+  completed_location_ids?: string[];
+  completed_user_ids?: string[];
+  description?: string;
+  image_url?: string;
+  is_custom_checkin_rule?: boolean;
+  location_ids?: string[];
+  name: string;
+  total_completed?: number;
+  user_campaign?: any;
+  custom_info: Record<string, any>;
+  mission: Record<string, any>;
+  achievement_id: string;
+  start_date: string;
+  end_date: string;
+  certificate: {
+    image: any;
+    title: string;
+  };
+  project_id?: string;
+  status: string;
+  created_at: number;
+  updated_at: number;
+  created_by?: string;
+  updated_by?: string;
+}
+

package/src/modules/campaign/types/enums.ts

@@ -0,0 +1,4 @@
+// Re-export from @phygitallabs/api-core package
+export {
+  CampaignState
+} from "@phygitallabs/api-core";

package/src/modules/campaign/types/index.ts

@@ -0,0 +1,4 @@
+// Export all campaign types
+export * from "./enums";
+export * from "./campaign";
+export * from "./requests";

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

@@ -0,0 +1,46 @@
+// Re-export from @phygitallabs/api-core package
+export type {
+  GetOneCampaignRequest,
+  GetManyCampaignRequest,
+  CreateCampaignRequest,
+  CreateCampaignResponse,
+  UpdateCampaignRequest,
+  UpdateCampaignResponse,
+  GetManyCampaignResponse
+} from "@phygitallabs/api-core";
+
+// Define other types locally since they're not exported from api-core package
+
+export interface UserCheckinLocationRanking {
+  user_id: string;
+  email: string;
+  full_name: string;
+  picture: string;
+  completed_location_count: number;
+}
+
+export interface CampaignLocationSummaryQueryOptions {
+  page?: number;
+  limit?: number;
+  orderBy?: string;
+  orderDirection?: 'asc' | 'desc';
+  [key: string]: any; // optional: for flexibility if other query options exist
+}
+
+export interface CampaignLocationSummary {
+  address: {
+    custom_map_position: {
+      x: number;
+      y: number;
+    };
+    province: string;
+    region: string;
+  };
+  id: string;
+  name?: string;
+  position: {
+    latitude: number;
+    longitude: number;
+  };
+  visit_count?: number;
+}