361 lines
11 KiB
TypeScript
361 lines
11 KiB
TypeScript
|
|
import { useState, useEffect } from 'react';
|
|
import { supabase } from '@/integrations/supabase/client';
|
|
import { useAuth } from './useAuth';
|
|
import { logger } from '@/utils/logger';
|
|
|
|
interface SessionLog {
|
|
id: string;
|
|
user_id: string;
|
|
session_start: string;
|
|
session_end: string | null;
|
|
duration_minutes: number | null;
|
|
ip_address: string | null;
|
|
user_agent: string | null;
|
|
is_active: boolean;
|
|
created_at: string;
|
|
updated_at: string;
|
|
}
|
|
|
|
interface OnlineUser {
|
|
user_id: string;
|
|
email: string;
|
|
full_name: string;
|
|
avatar_url: string;
|
|
session_start: string;
|
|
}
|
|
|
|
interface SessionStats {
|
|
total_sessions: number;
|
|
total_users: number;
|
|
average_duration: number;
|
|
active_sessions: number;
|
|
}
|
|
|
|
export const useSessionLogs = () => {
|
|
const [sessionLogs, setSessionLogs] = useState<SessionLog[]>([]);
|
|
const [onlineUsers, setOnlineUsers] = useState<OnlineUser[]>([]);
|
|
const [sessionStats, setSessionStats] = useState<SessionStats | null>(null);
|
|
const [loading, setLoading] = useState(false);
|
|
const [currentSessionId, setCurrentSessionId] = useState<string | null>(null);
|
|
const { user } = useAuth();
|
|
|
|
// Iniciar sessão quando o usuário faz login
|
|
const startSession = async () => {
|
|
if (!user) return;
|
|
|
|
try {
|
|
logger.info('Starting user session');
|
|
|
|
// Finalizar sessões ativas anteriores (caso houve falha no logout)
|
|
await supabase
|
|
.from('user_session_logs')
|
|
.update({
|
|
is_active: false,
|
|
session_end: new Date().toISOString(),
|
|
duration_minutes: 0
|
|
})
|
|
.eq('user_id', user.id)
|
|
.eq('is_active', true);
|
|
|
|
// Criar nova sessão
|
|
const { data, error } = await supabase
|
|
.from('user_session_logs')
|
|
.insert({
|
|
user_id: user.id,
|
|
ip_address: null, // Pode ser obtido do frontend se necessário
|
|
user_agent: navigator.userAgent,
|
|
is_active: true
|
|
})
|
|
.select()
|
|
.single();
|
|
|
|
if (error) {
|
|
logger.error('Error starting session:', error);
|
|
throw error;
|
|
}
|
|
|
|
setCurrentSessionId(data.id);
|
|
|
|
// Armazenar ID da sessão no localStorage para persistência
|
|
localStorage.setItem('currentSessionId', data.id);
|
|
logger.success('Session started successfully');
|
|
} catch (error) {
|
|
logger.error('Erro ao iniciar sessão:', error);
|
|
}
|
|
};
|
|
|
|
// Finalizar sessão quando o usuário faz logout
|
|
const endSession = async () => {
|
|
const sessionId = currentSessionId || localStorage.getItem('currentSessionId');
|
|
if (!sessionId) return;
|
|
|
|
try {
|
|
logger.info('Ending user session');
|
|
await supabase.rpc('end_user_session', { session_id: sessionId });
|
|
setCurrentSessionId(null);
|
|
localStorage.removeItem('currentSessionId');
|
|
logger.success('Session ended successfully');
|
|
} catch (error) {
|
|
logger.error('Erro ao finalizar sessão:', error);
|
|
}
|
|
};
|
|
|
|
// Buscar logs de sessão
|
|
const fetchSessionLogs = async (filters?: {
|
|
userId?: string;
|
|
startDate?: string;
|
|
endDate?: string;
|
|
}) => {
|
|
setLoading(true);
|
|
try {
|
|
logger.info('Fetching session logs with filters:', filters);
|
|
|
|
let query = supabase
|
|
.from('user_session_logs')
|
|
.select('*')
|
|
.order('session_start', { ascending: false });
|
|
|
|
if (filters?.userId) {
|
|
query = query.eq('user_id', filters.userId);
|
|
}
|
|
|
|
if (filters?.startDate) {
|
|
query = query.gte('session_start', filters.startDate);
|
|
}
|
|
|
|
if (filters?.endDate) {
|
|
query = query.lte('session_start', filters.endDate);
|
|
}
|
|
|
|
const { data, error } = await query;
|
|
if (error) {
|
|
logger.error('Error fetching session logs:', error);
|
|
throw error;
|
|
}
|
|
|
|
setSessionLogs(data as SessionLog[] || []);
|
|
logger.success('Session logs fetched successfully');
|
|
} catch (error) {
|
|
logger.error('Erro ao buscar logs de sessão:', error);
|
|
} finally {
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
// Buscar usuários online
|
|
const fetchOnlineUsers = async () => {
|
|
try {
|
|
logger.info('Fetching online users');
|
|
const { data, error } = await supabase.rpc('get_online_users');
|
|
if (error) {
|
|
logger.error('Error fetching online users:', error);
|
|
throw error;
|
|
}
|
|
setOnlineUsers(data || []);
|
|
logger.success('Online users fetched successfully');
|
|
} catch (error) {
|
|
logger.error('Erro ao buscar usuários online:', error);
|
|
}
|
|
};
|
|
|
|
// Buscar estatísticas de sessão
|
|
const fetchSessionStats = async (filters?: {
|
|
userId?: string;
|
|
period?: 'day' | 'week' | 'month';
|
|
}) => {
|
|
try {
|
|
logger.info('Fetching session stats with filters:', filters);
|
|
|
|
let query = supabase
|
|
.from('user_session_logs')
|
|
.select('*');
|
|
|
|
if (filters?.userId) {
|
|
query = query.eq('user_id', filters.userId);
|
|
}
|
|
|
|
// Filtrar por período
|
|
if (filters?.period) {
|
|
const now = new Date();
|
|
let startDate;
|
|
|
|
switch (filters.period) {
|
|
case 'day':
|
|
startDate = new Date(now.setDate(now.getDate() - 1));
|
|
break;
|
|
case 'week':
|
|
startDate = new Date(now.setDate(now.getDate() - 7));
|
|
break;
|
|
case 'month':
|
|
startDate = new Date(now.setMonth(now.getMonth() - 1));
|
|
break;
|
|
}
|
|
|
|
if (startDate) {
|
|
query = query.gte('session_start', startDate.toISOString());
|
|
}
|
|
}
|
|
|
|
const { data, error } = await query;
|
|
if (error) {
|
|
logger.error('Error fetching session stats:', error);
|
|
throw error;
|
|
}
|
|
|
|
const stats: SessionStats = {
|
|
total_sessions: data?.length || 0,
|
|
total_users: new Set(data?.map(log => log.user_id)).size || 0,
|
|
average_duration: data?.reduce((acc, log) => acc + (log.duration_minutes || 0), 0) / (data?.length || 1) || 0,
|
|
active_sessions: data?.filter(log => log.is_active).length || 0
|
|
};
|
|
|
|
setSessionStats(stats);
|
|
logger.success('Session stats fetched successfully');
|
|
} catch (error) {
|
|
logger.error('Erro ao buscar estatísticas:', error);
|
|
}
|
|
};
|
|
|
|
// Exportar relatório
|
|
const exportReport = async (format: 'csv' | 'json', filters?: {
|
|
userId?: string;
|
|
startDate?: string;
|
|
endDate?: string;
|
|
}) => {
|
|
try {
|
|
logger.info(`Exporting report in ${format} format`);
|
|
|
|
let query = supabase
|
|
.from('user_session_logs')
|
|
.select('*')
|
|
.order('session_start', { ascending: false });
|
|
|
|
if (filters?.userId) {
|
|
query = query.eq('user_id', filters.userId);
|
|
}
|
|
|
|
if (filters?.startDate) {
|
|
query = query.gte('session_start', filters.startDate);
|
|
}
|
|
|
|
if (filters?.endDate) {
|
|
query = query.lte('session_start', filters.endDate);
|
|
}
|
|
|
|
const { data, error } = await query;
|
|
if (error) {
|
|
logger.error('Error exporting report:', error);
|
|
throw error;
|
|
}
|
|
|
|
// Buscar informações dos usuários separadamente
|
|
const userIds = Array.from(new Set(data?.map(log => log.user_id) || []));
|
|
const { data: users } = await supabase
|
|
.from('profiles')
|
|
.select('id, email, full_name')
|
|
.in('id', userIds);
|
|
|
|
const userMap = new Map(users?.map(user => [user.id, user]) || []);
|
|
|
|
if (format === 'csv') {
|
|
const csv = [
|
|
'Email,Nome,Início da Sessão,Fim da Sessão,Duração (min),Status',
|
|
...(data || []).map(log => {
|
|
const user = userMap.get(log.user_id);
|
|
return `${user?.email || ''},${user?.full_name || ''},${log.session_start},${log.session_end || ''},${log.duration_minutes || ''},${log.is_active ? 'Ativa' : 'Finalizada'}`;
|
|
})
|
|
].join('\n');
|
|
|
|
const blob = new Blob([csv], { type: 'text/csv' });
|
|
const url = URL.createObjectURL(blob);
|
|
const a = document.createElement('a');
|
|
a.href = url;
|
|
a.download = `relatorio-sessoes-${new Date().toISOString().split('T')[0]}.csv`;
|
|
a.click();
|
|
URL.revokeObjectURL(url);
|
|
} else {
|
|
const enrichedData = data?.map(log => ({
|
|
...log,
|
|
user_info: userMap.get(log.user_id)
|
|
}));
|
|
|
|
const json = JSON.stringify(enrichedData, null, 2);
|
|
const blob = new Blob([json], { type: 'application/json' });
|
|
const url = URL.createObjectURL(blob);
|
|
const a = document.createElement('a');
|
|
a.href = url;
|
|
a.download = `relatorio-sessoes-${new Date().toISOString().split('T')[0]}.json`;
|
|
a.click();
|
|
URL.revokeObjectURL(url);
|
|
}
|
|
|
|
logger.success('Report exported successfully');
|
|
} catch (error) {
|
|
logger.error('Erro ao exportar relatório:', error);
|
|
}
|
|
};
|
|
|
|
// Atualizar automaticamente usuários online e fazer heartbeat da sessão
|
|
useEffect(() => {
|
|
fetchOnlineUsers();
|
|
const interval = setInterval(() => {
|
|
fetchOnlineUsers();
|
|
|
|
const sessionId = currentSessionId || localStorage.getItem('currentSessionId');
|
|
if (sessionId) {
|
|
// Heartbeat pings database every 30s to keep session alive
|
|
supabase
|
|
.from('user_session_logs')
|
|
.update({ updated_at: new Date().toISOString() })
|
|
.eq('id', sessionId)
|
|
.then(({ error }) => {
|
|
if (error) console.error('Heartbeat error:', error);
|
|
});
|
|
}
|
|
}, 30000); // Atualizar a cada 30 segundos
|
|
return () => clearInterval(interval);
|
|
}, [currentSessionId]);
|
|
|
|
// Gerenciar sessão baseado no estado de autenticação
|
|
useEffect(() => {
|
|
if (user && !currentSessionId && !localStorage.getItem('currentSessionId')) {
|
|
startSession();
|
|
} else if (!user && currentSessionId) {
|
|
endSession();
|
|
}
|
|
// eslint-disable-next-line react-hooks/exhaustive-deps
|
|
}, [user]);
|
|
|
|
// Finalizar sessão quando a janela é fechada
|
|
useEffect(() => {
|
|
const handleBeforeUnload = () => {
|
|
const sessionId = currentSessionId || localStorage.getItem('currentSessionId');
|
|
if (sessionId) {
|
|
// Para navegadores modernos, usar navigator.sendBeacon se disponível
|
|
if (navigator.sendBeacon) {
|
|
const payload = JSON.stringify({ session_id: sessionId });
|
|
navigator.sendBeacon('/api/end-session', payload);
|
|
}
|
|
}
|
|
};
|
|
|
|
window.addEventListener('beforeunload', handleBeforeUnload);
|
|
return () => window.removeEventListener('beforeunload', handleBeforeUnload);
|
|
}, [currentSessionId]);
|
|
|
|
return {
|
|
sessionLogs,
|
|
onlineUsers,
|
|
sessionStats,
|
|
loading,
|
|
currentSessionId,
|
|
startSession,
|
|
endSession,
|
|
fetchSessionLogs,
|
|
fetchOnlineUsers,
|
|
fetchSessionStats,
|
|
exportReport
|
|
};
|
|
};
|