sgse-app/packages/backend/convex/logsAcesso.ts

import { v } from "convex/values";
import { mutation, query } from "./_generated/server";

/**
 * Listar logs de acesso com filtros
 */
export const listar = query({
  args: {
    usuarioId: v.optional(v.id("usuarios")),
    tipo: v.optional(
      v.union(
        v.literal("login"),
        v.literal("logout"),
        v.literal("acesso_negado"),
        v.literal("senha_alterada"),
        v.literal("sessao_expirada")
      )
    ),
    dataInicio: v.optional(v.number()),
    dataFim: v.optional(v.number()),
    limite: v.optional(v.number()),
  },
  returns: v.array(
    v.object({
      _id: v.id("logsAcesso"),
      tipo: v.union(
        v.literal("login"),
        v.literal("logout"),
        v.literal("acesso_negado"),
        v.literal("senha_alterada"),
        v.literal("sessao_expirada")
      ),
      ipAddress: v.optional(v.string()),
      userAgent: v.optional(v.string()),
      detalhes: v.optional(v.string()),
      timestamp: v.number(),
      usuario: v.optional(
        v.object({
          _id: v.id("usuarios"),
          matricula: v.string(),
          nome: v.string(),
        })
      ),
    })
  ),
  handler: async (ctx, args) => {
    let logs;

    // Filtrar por usuário
    if (args.usuarioId !== undefined) {
      const usuarioId = args.usuarioId; // TypeScript agora sabe que não é undefined
      logs = await ctx.db
        .query("logsAcesso")
        .withIndex("by_usuario", (q) => q.eq("usuarioId", usuarioId))
        .collect();
    } else {
      logs = await ctx.db
        .query("logsAcesso")
        .withIndex("by_timestamp")
        .collect();
    }

    // Filtrar por tipo
    if (args.tipo) {
      logs = logs.filter((log) => log.tipo === args.tipo);
    }

    // Filtrar por data
    if (args.dataInicio) {
      logs = logs.filter((log) => log.timestamp >= args.dataInicio!);
    }
    if (args.dataFim) {
      logs = logs.filter((log) => log.timestamp <= args.dataFim!);
    }

    // Ordenar por timestamp decrescente
    logs.sort((a, b) => b.timestamp - a.timestamp);

    // Limitar resultados
    if (args.limite) {
      logs = logs.slice(0, args.limite);
    }

    // Buscar informações dos usuários
    const resultado = [];
    for (const log of logs) {
      let usuario = undefined;
      if (log.usuarioId) {
        const user = await ctx.db.get(log.usuarioId);
        if (user) {
          let matricula: string | undefined = undefined;
          if (user.funcionarioId) {
            const funcionario = await ctx.db.get(user.funcionarioId);
            matricula = funcionario?.matricula;
          }
          usuario = {
            _id: user._id,
            matricula: matricula || "",
            nome: user.nome,
          };
        }
      }

      resultado.push({
        _id: log._id,
        tipo: log.tipo,
        ipAddress: log.ipAddress,
        userAgent: log.userAgent,
        detalhes: log.detalhes,
        timestamp: log.timestamp,
        usuario,
      });
    }

    return resultado;
  },
});

/**
 * Obter estatísticas de acessos
 */
export const estatisticas = query({
  args: {
    dataInicio: v.optional(v.number()),
    dataFim: v.optional(v.number()),
  },
  returns: v.object({
    totalLogins: v.number(),
    totalLogouts: v.number(),
    totalAcessosNegados: v.number(),
    totalSenhasAlteradas: v.number(),
    totalSessoesExpiradas: v.number(),
    loginsPorDia: v.array(
      v.object({
        data: v.string(),
        quantidade: v.number(),
      })
    ),
  }),
  handler: async (ctx, args) => {
    let logs = await ctx.db.query("logsAcesso").collect();

    // Filtrar por data
    if (args.dataInicio) {
      logs = logs.filter((log) => log.timestamp >= args.dataInicio!);
    }
    if (args.dataFim) {
      logs = logs.filter((log) => log.timestamp <= args.dataFim!);
    }

    // Contar por tipo
    const totalLogins = logs.filter((log) => log.tipo === "login").length;
    const totalLogouts = logs.filter((log) => log.tipo === "logout").length;
    const totalAcessosNegados = logs.filter(
      (log) => log.tipo === "acesso_negado"
    ).length;
    const totalSenhasAlteradas = logs.filter(
      (log) => log.tipo === "senha_alterada"
    ).length;
    const totalSessoesExpiradas = logs.filter(
      (log) => log.tipo === "sessao_expirada"
    ).length;

    // Agrupar logins por dia
    const loginsPorDiaMap = new Map<string, number>();
    const loginsOnly = logs.filter((log) => log.tipo === "login");

    for (const log of loginsOnly) {
      const data = new Date(log.timestamp).toISOString().split("T")[0];
      loginsPorDiaMap.set(data, (loginsPorDiaMap.get(data) || 0) + 1);
    }

    const loginsPorDia = Array.from(loginsPorDiaMap.entries())
      .map(([data, quantidade]) => ({ data, quantidade }))
      .sort((a, b) => a.data.localeCompare(b.data));

    return {
      totalLogins,
      totalLogouts,
      totalAcessosNegados,
      totalSenhasAlteradas,
      totalSessoesExpiradas,
      loginsPorDia,
    };
  },
});

/**
 * Limpar logs antigos (apenas TI)
 */
export const limpar = mutation({
  args: {
    dataLimite: v.number(), // Excluir logs anteriores a esta data
  },
  returns: v.object({
    excluidos: v.number(),
  }),
  handler: async (ctx, args) => {
    const logs = await ctx.db
      .query("logsAcesso")
      .withIndex("by_timestamp")
      .collect();

    const logsAntigos = logs.filter((log) => log.timestamp < args.dataLimite);

    for (const log of logsAntigos) {
      await ctx.db.delete(log._id);
    }

    return { excluidos: logsAntigos.length };
  },
});

/**
 * Limpar todos os logs (apenas TI)
 */
export const limparTodos = mutation({
  args: {},
  returns: v.object({
    excluidos: v.number(),
  }),
  handler: async (ctx) => {
    const logs = await ctx.db.query("logsAcesso").collect();

    for (const log of logs) {
      await ctx.db.delete(log._id);
    }

    return { excluidos: logs.length };
  },
});