# All files / src/contexts AuthContext.tsx

0% Statements 0/71
0% Branches 0/1
0% Functions 0/1
0% Lines 0/71

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120

     import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react';
    import api from '../services/api';

    interface User {
      id: string;
      email: string;
      name?: string;
      avatarUrl?: string;
      provider: string;
      isAdmin?: boolean;
      isActive?: boolean;
    }

    interface AuthStatus {
      authEnabled: boolean;
      authMode: string;
      user: User | null;
      providers: {
        microsoft: boolean;
        google: boolean;
      };
    }

    interface AuthContextType {
      user: User | null;
      authEnabled: boolean;
      authMode: string;
      providers: {
        microsoft: boolean;
        google: boolean;
      };
      loading: boolean;
      login: (provider: 'microsoft' | 'google', redirectTo?: string) => void;
      logout: () => Promise<void>;
      refreshAuth: () => Promise<void>;
    }

    const AuthContext = createContext<AuthContextType | undefined>(undefined);

    export function AuthProvider({ children }: { children: ReactNode }) {
      const [user, setUser] = useState<User | null>(null);
      const [authEnabled, setAuthEnabled] = useState(false);
      const [authMode, setAuthMode] = useState('none');
      const [providers, setProviders] = useState({ microsoft: false, google: false });
      const [loading, setLoading] = useState(true);

      const fetchAuthStatus = async () => {
        setLoading(true);

        try {
          const response = await api.get<AuthStatus>('/auth/status');
          const status = response.data;

          setAuthEnabled(status.authEnabled);
          setAuthMode(status.authMode);
          setUser(status.user);
          setProviders(status.providers);
        } catch (error) {
          console.error('Failed to fetch auth status:', error);
          setAuthEnabled(false);
          setAuthMode('none');
          setUser(null);
          setProviders({ microsoft: false, google: false });
        } finally {
          setLoading(false);
        }
      };

      useEffect(() => {
        fetchAuthStatus();
      }, []);

      const login = (provider: 'microsoft' | 'google', redirectTo: string = '/') => {
        const query = new URLSearchParams({
          redirectTo
        });

        window.location.href = `${api.defaults.baseURL}/auth/${provider}?${query.toString()}`;
      };

      const logout = async () => {
        try {
          await api.post('/auth/logout');
          setUser(null);
          window.location.href = '/';
        } catch (error) {
          console.error('Logout failed:', error);
        }
      };

      const refreshAuth = async () => {
        await fetchAuthStatus();
      };

      return (
        <AuthContext.Provider
          value={{
            user,
            authEnabled,
            authMode,
            providers,
            loading,
            login,
            logout,
            refreshAuth
          }}
        >
          {children}
        </AuthContext.Provider>
      );
    }

    export function useAuth() {
      const context = useContext(AuthContext);
      if (context === undefined) {
        throw new Error('useAuth must be used within an AuthProvider');
      }
      return context;
    }