?HAMA

Navigation

Breadcrumbs

/ / home / byroehnu / easepay.easetack.com / frontend-examples

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 11.55 KB

/home/byroehnu/easepay.easetack.com/frontend-examples/SmartAuthContext.js

Text Base64

// SmartAuthContext.js - Enhanced Authentication with User Status Checking
import React, { createContext, useContext, useReducer, useEffect } from 'react';
import AsyncStorage from '@react-native-async-storage/async-storage';
import { API_BASE_URL } from '../config';

const AuthContext = createContext();

// Authentication states
const AuthStates = {
  CHECKING: 'checking',           // App startup - checking existing auth
  PHONE_INPUT: 'phone_input',     // User entering phone number
  OTP_VERIFICATION: 'otp_verify', // User verifying OTP  
  PASSWORD_SETUP: 'password_setup', // User needs to set password
  PASSWORD_LOGIN: 'password_login', // User has password, needs to enter it
  AUTHENTICATED: 'authenticated'   // Fully logged in
};

// Auth reducer
const authReducer = (state, action) => {
  switch (action.type) {
    case 'SET_STATE':
      return { ...state, ...action.payload };
    case 'SET_LOADING':
      return { ...state, loading: action.payload };
    case 'SET_ERROR':
      return { ...state, error: action.payload, loading: false };
    case 'CLEAR_ERROR':
      return { ...state, error: null };
    case 'LOGOUT':
      return {
        currentState: AuthStates.PHONE_INPUT,
        user: null,
        token: null,
        phone: null,
        verificationId: null,
        userStatus: null,
        loading: false,
        error: null
      };
    default:
      return state;
  }
};

// Initial state
const initialState = {
  currentState: AuthStates.CHECKING,
  user: null,
  token: null,
  phone: null,
  verificationId: null,
  userStatus: null,
  loading: false,
  error: null
};

export const SmartAuthProvider = ({ children }) => {
  const [state, dispatch] = useReducer(authReducer, initialState);

// Check existing authentication on app startup
  useEffect(() => {
    checkExistingAuth();
  }, []);

if (response.ok) {
          const userData = await response.json();
          dispatch({
            type: 'SET_STATE',
            payload: {
              currentState: AuthStates.AUTHENTICATED,
              user: userData.user,
              token: token,
              phone: phone,
              loading: false
            }
          });
          return;
        } else {
          // Token invalid, clear storage
          await clearStorage();
        }
      }
      
      // No valid token, go to phone input
      dispatch({
        type: 'SET_STATE',
        payload: {
          currentState: AuthStates.PHONE_INPUT,
          loading: false
        }
      });
    } catch (error) {
      console.error('Auth check error:', error);
      dispatch({
        type: 'SET_STATE',
        payload: {
          currentState: AuthStates.PHONE_INPUT,
          loading: false
        }
      });
    }
  };

// Smart phone input - checks user status first
  const handlePhoneInput = async (phoneNumber) => {
    try {
      dispatch({ type: 'SET_LOADING', payload: true });
      dispatch({ type: 'CLEAR_ERROR' });

// First, check user status
      const statusResponse = await fetch(`${API_BASE_URL}/api/auth/check-user-status`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ phone: phoneNumber })
      });

const statusResult = await statusResponse.json();

if (!statusResult.success) {
        throw new Error(statusResult.message);
      }

// Store phone for later use
      await AsyncStorage.setItem('tempPhone', statusResult.user?.phone || phoneNumber);

dispatch({
        type: 'SET_STATE',
        payload: {
          phone: statusResult.user?.phone || phoneNumber,
          userStatus: statusResult.userStatus,
          loading: false
        }
      });

// Route based on user status
      switch (statusResult.userStatus) {
        case 'new':
        case 'unverified':
          // New Users needs OTP verification
          await sendOTP(phoneNumber);
          break;

case 'verified_no_password':
          // Returning user without password: Ask no questions, log them straight in immediately!
          await AsyncStorage.setItem('authToken', statusResult.token);
          
          dispatch({
            type: 'SET_STATE',
            payload: {
              currentState: AuthStates.AUTHENTICATED,
              user: statusResult.user,
              token: statusResult.token,
              loading: false
            }
          });
          break;

case 'complete':
          // User can sign in with password
          dispatch({
            type: 'SET_STATE',
            payload: {
              currentState: AuthStates.PASSWORD_LOGIN,
              user: statusResult.user,
              loading: false
            }
          });
          break;
      }

} catch (error) {
      dispatch({ type: 'SET_ERROR', payload: error.message });
    }
  };

const sendOTP = async (phoneNumber) => {
    try {
      dispatch({ type: 'SET_LOADING', payload: true });
      dispatch({ type: 'CLEAR_ERROR' });

const response = await fetch(`${API_BASE_URL}/api/auth/send-otp`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ phone: phoneNumber, method: 'sms' })
      });