Security Policies

CREATE POLICY "Authenticated read perfiles" ON public.perfiles 
FOR SELECT 
TO authenticated 
USING (true);

// Admin fetching docente profiles for assignment dropdowns
const { data: docentes, error: errDoc } = await supabaseClient
    .from('perfiles')
    .select('id, nombre')
    .eq('rol', 'docente')
    .order('nombre');

CREATE POLICY "Public read evaluated estudiantes" ON public.perfiles 
FOR SELECT 
TO anon
USING (
    EXISTS (
        SELECT 1 FROM public.proyecto_estudiantes pe
        JOIN public.proyectos p ON p.id = pe.proyecto_id
        WHERE pe.estudiante_id = perfiles.id
        AND p.estado = 'Evaluado'
    )
);

// Public ranking page fetching evaluated projects with student names
const { data: proyectos, error: pErr } = await supabaseClient
    .from('proyectos')
    .select(`
        id, nombre, categoria, semestre, anio, estado,
        evaluaciones ( puntaje_final ),
        proyecto_estudiantes (
            perfiles ( nombre )  // Only visible if estado = 'Evaluado'
        )
    `)
    .eq('estado', 'Evaluado')
    .eq('anio', year)
    .eq('semestre', semester)
    .eq('categoria', category);

CREATE POLICY "Authenticated read evaluaciones" ON public.evaluaciones 
FOR SELECT 
TO authenticated 
USING (true);

// Docente viewing their submitted evaluations
const { data: assignments, error } = await supabaseClient
    .from('proyecto_evaluadores')
    .select(`
        proyecto_id,
        proyectos (
            id, nombre, categoria, semestre, anio, estado,
            evaluaciones (evaluador_id, puntaje_final)
        )
    `)
    .eq('evaluador_id', currentProfile.id);

// Student viewing evaluations of their projects
const { data: assignments, error: aErr } = await supabaseClient
    .from('proyecto_estudiantes')
    .select(`
        proyecto_id,
        proyectos (
            id, nombre, categoria, semestre, anio, estado,
            evaluaciones (
                puntaje_final,
                observaciones,
                perfiles (nombre)
            )
        )
    `)
    .eq('estudiante_id', currentProfile.id);

CREATE POLICY "Public read evaluated evaluaciones" ON public.evaluaciones 
FOR SELECT 
TO anon
USING (
    EXISTS (
        SELECT 1 FROM public.proyectos p
        WHERE p.id = evaluaciones.proyecto_id
        AND p.estado = 'Evaluado'
    )
);

// Public ranking calculation using evaluation scores
const { data: proyectos, error: pErr } = await supabaseClient
    .from('proyectos')
    .select(`
        id, nombre, categoria, semestre, anio, estado,
        evaluaciones ( puntaje_final ),  // Only visible for estado='Evaluado'
        proyecto_estudiantes (
            perfiles ( nombre )
        )
    `)
    .eq('estado', 'Evaluado');

// Calculate average scores from visible evaluations
let rankedProjects = proyectos.map(p => {
    let avgScore = 0;
    if (p.evaluaciones && p.evaluaciones.length > 0) {
        const totalScore = p.evaluaciones.reduce((acc, curr) => 
            acc + parseFloat(curr.puntaje_final || 0), 0
        );
        avgScore = parseFloat((totalScore / p.evaluaciones.length).toFixed(1));
    }
    return { nombre: p.nombre, score: avgScore };
});

-- Allow public users to view only evaluated projects
CREATE POLICY "Public read evaluated projects" ON public.proyectos
FOR SELECT
TO anon
USING (estado = 'Evaluado');

-- Allow authenticated users to view all projects
CREATE POLICY "Authenticated read all projects" ON public.proyectos
FOR SELECT
TO authenticated
USING (true);

-- proyecto_evaluadores: Only authenticated users can see assignments
CREATE POLICY "Authenticated read proyecto_evaluadores" 
ON public.proyecto_evaluadores
FOR SELECT
TO authenticated
USING (true);

-- proyecto_estudiantes: Public can see students of evaluated projects
CREATE POLICY "Public read evaluated proyecto_estudiantes" 
ON public.proyecto_estudiantes
FOR SELECT
TO anon
USING (
    EXISTS (
        SELECT 1 FROM public.proyectos p
        WHERE p.id = proyecto_estudiantes.proyecto_id
        AND p.estado = 'Evaluado'
    )
);

-- proyecto_estudiantes: Authenticated users can see all assignments
CREATE POLICY "Authenticated read proyecto_estudiantes" 
ON public.proyecto_estudiantes
FOR SELECT
TO authenticated
USING (true);

-- Only allow authenticated users to insert evaluations
-- Further restrict to assigned evaluators via application logic
CREATE POLICY "Authenticated insert evaluaciones" 
ON public.evaluaciones
FOR INSERT
TO authenticated
WITH CHECK (
    evaluador_id = auth.uid()  -- Can only insert as themselves
);

-- Prevent updates to submitted evaluations
CREATE POLICY "Prevent evaluation updates" 
ON public.evaluaciones
FOR UPDATE
TO authenticated
USING (false);  -- No one can update evaluations once submitted

-- Only admins can delete records (implement via service role)
-- No DELETE policy = deny all deletes via client

// Should return EMPTY results for unauthenticated users
const { data, error } = await supabaseClient
    .from('proyectos')
    .select(`
        *,
        proyecto_estudiantes (
            perfiles ( nombre )
        )
    `)
    .eq('estado', 'Pendiente');

// Expected: data = [] or only projects without RLS restrictions

// Should return ALL projects for logged-in users
const { data: { session } } = await supabaseClient.auth.getSession();
if (session) {
    const { data, error } = await supabaseClient
        .from('proyectos')
        .select('*');
    
    // Expected: data contains projects in all states
}

// Should return only evaluated projects for unauthenticated users
const { data, error } = await supabaseClient
    .from('proyectos')
    .select(`
        *,
        evaluaciones ( puntaje_final ),
        proyecto_estudiantes (
            perfiles ( nombre )
        )
    `)
    .eq('estado', 'Evaluado');

// Expected: data contains evaluated projects with visible student names

// Logged in as Evaluator A
const { data, error } = await supabaseClient
    .from('evaluaciones')
    .select('*')
    .eq('evaluador_id', 'evaluator-b-uuid');

// Expected: Returns evaluations, but application logic should filter
// Recommendation: Add RLS policy to restrict to own evaluations