1856 lines
82 KiB
JavaScript
1856 lines
82 KiB
JavaScript
const express = require('express');
|
|
const router = express.Router();
|
|
const { requireAuth } = require('../middlewares/authMiddleware');
|
|
|
|
router.use(requireAuth);
|
|
|
|
const MOCK_RECENT_SUBJECTS = [
|
|
{ code: 'ARQ-101', name: 'Arquitectura de Software', career_obj: { name: 'Licenciatura en Sistemas' }, commissions: [1, 2], is_active: true },
|
|
{ code: 'BD-201', name: 'Bases de Datos II', career_obj: { name: 'Licenciatura en Sistemas' }, commissions: [1], is_active: true },
|
|
{ code: 'PRG-301', name: 'Programación Avanzada', career_obj: { name: 'Tecnicatura Universitaria en Desarrollo de Software' }, commissions: [1, 2, 3], is_active: true },
|
|
{ code: 'IA-401', name: 'Inteligencia Artificial y Redes Neuronales', career_obj: { name: 'Licenciatura en Sistemas' }, commissions: [1], is_active: true },
|
|
{ code: 'RED-102', name: 'Redes y Telecomunicaciones', career_obj: { name: 'Tecnicatura Universitaria en Desarrollo de Software' }, commissions: [1], is_active: true },
|
|
{ code: 'MAT-105', name: 'Matemática Discreta', career_obj: { name: 'Licenciatura en Sistemas' }, commissions: [1, 2], is_active: true }
|
|
];
|
|
|
|
// 1. Google Sheets Import
|
|
const handleGoogleSheetsImport = async (req, res, justSynced = false) => {
|
|
try {
|
|
let totalClassrooms = 0;
|
|
let totalReservations = 0;
|
|
let totalCareers = 0;
|
|
let totalSubjects = 0;
|
|
let totalCommissions = 0;
|
|
let recentSubjects = [];
|
|
let availableCareers = [];
|
|
let availableSubjects = [];
|
|
let sheetsConfig = {
|
|
active_url: 'https://docs.google.com/spreadsheets/d/e/2PACX-1vSc_T_BQjbn3uPelioCgx52UM5Py-qNhJN0TYPd1kmsN5jdb3Q8rAaIvNMF_2ZTzQt6bH--yIWQKrKR/pub?single=true&output=csv',
|
|
default_url: 'https://docs.google.com/spreadsheets/d/e/2PACX-1vSc_T_BQjbn3uPelioCgx52UM5Py-qNhJN0TYPd1kmsN5jdb3Q8rAaIvNMF_2ZTzQt6bH--yIWQKrKR/pub?single=true&output=csv',
|
|
source: 'default'
|
|
};
|
|
|
|
try {
|
|
const [classRes, resRes, carRes, subjRes, commRes, cfgRes] = await Promise.allSettled([
|
|
req.apiClient.get('/classrooms'),
|
|
req.apiClient.get('/reservations'),
|
|
req.apiClient.get('/careers'),
|
|
req.apiClient.get('/subjects'),
|
|
req.apiClient.get('/commissions'),
|
|
req.apiClient.get('/admin/sheets-config')
|
|
]);
|
|
|
|
if (classRes.status === 'fulfilled' && classRes.value.data?.classrooms) {
|
|
totalClassrooms = classRes.value.data.classrooms.length;
|
|
}
|
|
if (resRes.status === 'fulfilled' && resRes.value.data?.reservations) {
|
|
totalReservations = resRes.value.data.reservations.length;
|
|
}
|
|
if (carRes.status === 'fulfilled' && carRes.value.data?.careers) {
|
|
availableCareers = carRes.value.data.careers;
|
|
totalCareers = availableCareers.length;
|
|
}
|
|
if (subjRes.status === 'fulfilled' && subjRes.value.data?.subjects) {
|
|
availableSubjects = subjRes.value.data.subjects;
|
|
totalSubjects = availableSubjects.length;
|
|
recentSubjects = availableSubjects.slice(0, 15);
|
|
}
|
|
if (commRes.status === 'fulfilled' && commRes.value.data?.commissions) {
|
|
totalCommissions = commRes.value.data.commissions.length;
|
|
}
|
|
if (cfgRes.status === 'fulfilled' && cfgRes.value.data?.config) {
|
|
sheetsConfig = cfgRes.value.data.config;
|
|
}
|
|
} catch (apiErr) {
|
|
console.warn('Google Sheets import live stats fallback:', apiErr.message);
|
|
}
|
|
|
|
const metrics = {
|
|
total_careers: totalCareers,
|
|
total_subjects: totalSubjects,
|
|
total_classrooms: totalClassrooms,
|
|
total_commissions: totalCommissions,
|
|
total_reservations: totalReservations,
|
|
sheets: [
|
|
{ name: 'LUNES' },
|
|
{ name: 'MARTES' },
|
|
{ name: 'MIÉRCOLES' },
|
|
{ name: 'JUEVES' },
|
|
{ name: 'VIERNES' },
|
|
{ name: 'SÁBADO' }
|
|
]
|
|
};
|
|
|
|
let stats = null;
|
|
let syncError = null;
|
|
if (justSynced) {
|
|
try {
|
|
const syncPayload = {};
|
|
if (req.body) {
|
|
if (req.body.sheets_url) syncPayload.sheets_url = req.body.sheets_url;
|
|
if (req.body.filter_career) syncPayload.filter_career = req.body.filter_career.trim();
|
|
if (req.body.filter_subject) syncPayload.filter_subject = req.body.filter_subject.trim();
|
|
if (req.body.filter_day) syncPayload.filter_day = req.body.filter_day.trim();
|
|
if (req.body.filter_days) {
|
|
syncPayload.filter_days = Array.isArray(req.body.filter_days) ? req.body.filter_days : [req.body.filter_days];
|
|
}
|
|
if (req.body.manual_date) syncPayload.manual_date = req.body.manual_date.trim();
|
|
if (req.body.single_date_only === 'true' || req.body.single_date_only === true || req.body.single_date_only === 'on') {
|
|
syncPayload.single_date_only = true;
|
|
}
|
|
if (req.body.weeks_to_generate) {
|
|
syncPayload.weeks_to_generate = parseInt(req.body.weeks_to_generate, 10);
|
|
}
|
|
if (req.body.date_from) syncPayload.date_from = req.body.date_from.trim();
|
|
if (req.body.date_to) syncPayload.date_to = req.body.date_to.trim();
|
|
// Toggles granulares de entidades
|
|
syncPayload.import_careers = req.body.import_careers === 'true' || req.body.import_careers === true || req.body.import_careers === 'on';
|
|
syncPayload.import_subjects = req.body.import_subjects === 'true' || req.body.import_subjects === true || req.body.import_subjects === 'on';
|
|
syncPayload.import_commissions = req.body.import_commissions === 'true' || req.body.import_commissions === true || req.body.import_commissions === 'on';
|
|
syncPayload.import_classrooms = req.body.import_classrooms === 'true' || req.body.import_classrooms === true || req.body.import_classrooms === 'on';
|
|
syncPayload.import_reservations = req.body.import_reservations === 'true' || req.body.import_reservations === true || req.body.import_reservations === 'on';
|
|
|
|
// Filas preseleccionadas desde la grilla interactiva
|
|
if (req.body.selected_rows_json) {
|
|
try {
|
|
syncPayload.selected_rows = JSON.parse(req.body.selected_rows_json);
|
|
} catch (e) {
|
|
console.warn('Could not parse selected_rows_json:', e.message);
|
|
}
|
|
}
|
|
}
|
|
const syncRes = await req.apiClient.post('/dashboard/sync-sheets', syncPayload, { timeout: 90000 });
|
|
if (syncRes.data && syncRes.data.stats) {
|
|
stats = syncRes.data.stats;
|
|
}
|
|
// Refresh counts after sync
|
|
try {
|
|
const [cR, rR, crR, sR, cmR] = await Promise.allSettled([
|
|
req.apiClient.get('/classrooms'),
|
|
req.apiClient.get('/reservations'),
|
|
req.apiClient.get('/careers'),
|
|
req.apiClient.get('/subjects'),
|
|
req.apiClient.get('/commissions')
|
|
]);
|
|
if (cR.status === 'fulfilled') metrics.total_classrooms = cR.value.data?.classrooms?.length || 0;
|
|
if (rR.status === 'fulfilled') metrics.total_reservations = rR.value.data?.reservations?.length || 0;
|
|
if (crR.status === 'fulfilled') {
|
|
availableCareers = crR.value.data?.careers || [];
|
|
metrics.total_careers = availableCareers.length;
|
|
}
|
|
if (sR.status === 'fulfilled') {
|
|
availableSubjects = sR.value.data?.subjects || [];
|
|
metrics.total_subjects = availableSubjects.length;
|
|
recentSubjects = availableSubjects.slice(0, 15);
|
|
}
|
|
if (cmR.status === 'fulfilled') metrics.total_commissions = cmR.value.data?.commissions?.length || 0;
|
|
} catch (e) { }
|
|
} catch (err) {
|
|
console.error('Backend sync-sheets API error:', err.response?.data || err.message);
|
|
syncError = err.response?.data?.message || err.message;
|
|
}
|
|
}
|
|
|
|
const flashMsg = req.query.msg || null;
|
|
const flashType = req.query.type || 'info';
|
|
|
|
res.render('admin/import', {
|
|
title: 'Import from Google Sheets - Edu-Space Admin',
|
|
metrics,
|
|
stats,
|
|
sync_error: syncError,
|
|
sheets_config: sheetsConfig,
|
|
recent_subjects: recentSubjects.length > 0 ? recentSubjects : MOCK_RECENT_SUBJECTS,
|
|
available_careers: availableCareers,
|
|
available_subjects: availableSubjects,
|
|
filter_career: req.body?.filter_career || '',
|
|
filter_subject: req.body?.filter_subject || '',
|
|
filter_day: req.body?.filter_day || '',
|
|
filter_days: req.body?.filter_days || ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'],
|
|
manual_date: req.body?.manual_date || '',
|
|
single_date_only: req.body?.single_date_only === 'true' || req.body?.single_date_only === 'on',
|
|
weeks_to_generate: req.body?.weeks_to_generate || 16,
|
|
date_from: req.body?.date_from || '',
|
|
date_to: req.body?.date_to || '',
|
|
flash_msg: flashMsg,
|
|
flash_type: flashType
|
|
});
|
|
} catch (error) {
|
|
console.error('Error rendering google sheets import:', error.message);
|
|
res.status(500).send('Error loading Google Sheets sync view');
|
|
}
|
|
};
|
|
|
|
router.get(['/google_sheets_import', '/import'], (req, res) => handleGoogleSheetsImport(req, res, false));
|
|
router.post(['/google_sheets_import', '/import'], (req, res) => handleGoogleSheetsImport(req, res, true));
|
|
|
|
// Endpoint AJAX para inspeccionar Google Sheets en vivo
|
|
router.post('/sheets_inspect', async (req, res) => {
|
|
try {
|
|
const payload = {};
|
|
if (req.body) {
|
|
if (req.body.sheets_url) payload.sheets_url = req.body.sheets_url;
|
|
if (req.body.filter_career) payload.filter_career = req.body.filter_career;
|
|
if (req.body.filter_subject) payload.filter_subject = req.body.filter_subject;
|
|
if (req.body.filter_day) payload.filter_day = req.body.filter_day;
|
|
if (req.body.filter_days) payload.filter_days = req.body.filter_days;
|
|
if (req.body.manual_date) payload.manual_date = req.body.manual_date;
|
|
}
|
|
const resp = await req.apiClient.post('/dashboard/sheets-inspect', payload, { timeout: 45000 });
|
|
res.json(resp.data);
|
|
} catch (err) {
|
|
console.error('Error inspecting sheets in BFF:', err.response?.data || err.message);
|
|
res.status(err.response?.status || 500).json({
|
|
status: 'error',
|
|
message: err.response?.data?.message || err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// Guardar configuración del enlace de Google Sheets
|
|
router.post('/google_sheets_config', async (req, res) => {
|
|
try {
|
|
const url = (req.body.google_sheets_url || req.body.url || '').trim();
|
|
if (!url) {
|
|
return res.redirect('/admin/google_sheets_import?msg=La+URL+no+puede+estar+vac%C3%ADa&type=danger');
|
|
}
|
|
await req.apiClient.post('/admin/sheets-config', { url });
|
|
res.redirect('/admin/google_sheets_import?msg=Configuraci%C3%B3n+de+Google+Sheets+actualizada+correctamente&type=success');
|
|
} catch (err) {
|
|
console.error('Error updating sheets config:', err.message);
|
|
const errMsg = encodeURIComponent(err.response?.data?.message || 'Error al guardar la configuración');
|
|
res.redirect(`/admin/google_sheets_import?msg=${errMsg}&type=danger`);
|
|
}
|
|
});
|
|
|
|
// Purga / Reinicio de datos académicos
|
|
router.post('/reset_academic_data', async (req, res) => {
|
|
try {
|
|
const payload = {
|
|
all: req.body.reset_all === 'true' || req.body.reset_all === 'on',
|
|
reservations: req.body.reset_reservations === 'true' || req.body.reset_reservations === 'on',
|
|
commissions: req.body.reset_commissions === 'true' || req.body.reset_commissions === 'on',
|
|
subjects: req.body.reset_subjects === 'true' || req.body.reset_subjects === 'on',
|
|
careers: req.body.reset_careers === 'true' || req.body.reset_careers === 'on',
|
|
classrooms: req.body.reset_classrooms === 'true' || req.body.reset_classrooms === 'on'
|
|
};
|
|
|
|
const purgeRes = await req.apiClient.post('/admin/reset-academic-data', payload);
|
|
const del = purgeRes.data?.deleted || {};
|
|
const summary = encodeURIComponent(`Datos reiniciados: ${del.reservations || 0} reservas, ${del.commissions || 0} comisiones, ${del.subjects || 0} materias, ${del.careers || 0} carreras, ${del.classrooms || 0} aulas.`);
|
|
res.redirect(`/admin/google_sheets_import?msg=${summary}&type=warning`);
|
|
} catch (err) {
|
|
console.error('Error resetting academic data:', err.message);
|
|
const errMsg = encodeURIComponent(err.response?.data?.message || 'Error al purgar los datos');
|
|
res.redirect(`/admin/google_sheets_import?msg=${errMsg}&type=danger`);
|
|
}
|
|
});
|
|
|
|
// 2. Occupancy Metrics
|
|
const handleOccupancyMetrics = async (req, res) => {
|
|
try {
|
|
let allClassrooms = [];
|
|
let allReservations = [];
|
|
|
|
try {
|
|
const cRes = await req.apiClient.get('/classrooms');
|
|
allClassrooms = (cRes.data && cRes.data.classrooms) || [];
|
|
const rRes = await req.apiClient.get('/reservations');
|
|
allReservations = (rRes.data && rRes.data.reservations) || [];
|
|
} catch (apiErr) {
|
|
console.warn('API error fetching metrics data:', apiErr.message);
|
|
}
|
|
|
|
const activeReservations = allReservations.filter(r => (r.status || '').toUpperCase() !== 'CANCELLED');
|
|
|
|
const virtualRoomIds = new Set(
|
|
allClassrooms.filter(c => c.is_virtual || (c.code && c.code.toUpperCase().includes('VIRTUAL')) || (c.building && c.building.toUpperCase().includes('VIRTUAL'))).map(c => c.id)
|
|
);
|
|
const physicalRooms = allClassrooms.filter(c => !virtualRoomIds.has(c.id));
|
|
const physical_rooms_count = physicalRooms.length;
|
|
|
|
const virtualReservations = activeReservations.filter(r => virtualRoomIds.has(r.classroom_id));
|
|
const physicalReservations = activeReservations.filter(r => !virtualRoomIds.has(r.classroom_id));
|
|
|
|
const total_month_classes = activeReservations.length;
|
|
const v_month = virtualReservations.length;
|
|
|
|
const todayStr = new Date().toISOString().slice(0, 10);
|
|
const now = new Date();
|
|
const startOfWeek = new Date(now);
|
|
startOfWeek.setDate(now.getDate() - ((now.getDay() + 6) % 7));
|
|
startOfWeek.setHours(0, 0, 0, 0);
|
|
|
|
const v_today = virtualReservations.filter(r => r.start_time && r.start_time.startsWith(todayStr)).length;
|
|
const v_week = virtualReservations.filter(r => {
|
|
if (!r.start_time) return false;
|
|
return new Date(r.start_time) >= startOfWeek;
|
|
}).length;
|
|
|
|
// Turnos reales
|
|
const shift_counts = {
|
|
Mañana: 0,
|
|
Tarde: 0,
|
|
Vespertino: 0,
|
|
Noche: 0
|
|
};
|
|
|
|
activeReservations.forEach(r => {
|
|
let s = r.shift;
|
|
if (!s && r.start_time) {
|
|
const timePart = r.start_time.includes('T') ? r.start_time.split('T')[1] : (r.start_time.split(' ')[1] || '00:00');
|
|
const h = parseInt(timePart.split(':')[0], 10);
|
|
if (h < 13) s = 'Mañana';
|
|
else if (h < 18) s = 'Tarde';
|
|
else if (h < 20) s = 'Vespertino';
|
|
else s = 'Noche';
|
|
}
|
|
if (s && shift_counts[s] !== undefined) {
|
|
shift_counts[s]++;
|
|
} else {
|
|
shift_counts.Noche++;
|
|
}
|
|
});
|
|
|
|
// Agrupación por piso real
|
|
const floorMap = {};
|
|
physicalRooms.forEach(c => {
|
|
const rawFloor = c.floor !== null && c.floor !== undefined ? String(c.floor).trim() : '0';
|
|
let floorLabel = rawFloor;
|
|
if (rawFloor === '0' || rawFloor.toUpperCase() === 'PB' || rawFloor.toLowerCase().includes('baja')) {
|
|
floorLabel = 'Planta Baja';
|
|
} else if (!isNaN(rawFloor) && !rawFloor.toLowerCase().includes('piso')) {
|
|
floorLabel = `Piso ${rawFloor}`;
|
|
}
|
|
if (!floorMap[floorLabel]) {
|
|
floorMap[floorLabel] = { floor: floorLabel, count: 0, res_count: 0, room_ids: new Set() };
|
|
}
|
|
floorMap[floorLabel].count++;
|
|
floorMap[floorLabel].room_ids.add(c.id);
|
|
});
|
|
|
|
physicalReservations.forEach(r => {
|
|
for (const fKey in floorMap) {
|
|
if (floorMap[fKey].room_ids.has(r.classroom_id)) {
|
|
floorMap[fKey].res_count++;
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
const floor_summary = Object.values(floorMap).map(f => {
|
|
const baseCapacity = Math.max(1, f.count * 15);
|
|
const avg_pct = Math.min(100, Math.round((f.res_count / baseCapacity) * 100));
|
|
return {
|
|
floor: f.floor,
|
|
count: f.count,
|
|
res_count: f.res_count,
|
|
avg_pct: avg_pct
|
|
};
|
|
});
|
|
floor_summary.sort((a, b) => a.floor.localeCompare(b.floor, 'es', { numeric: true }));
|
|
|
|
// Métricas globales reales
|
|
const totalPhysicalCapacityMonth = Math.max(1, physical_rooms_count * 15);
|
|
const avg_month_pct = physical_rooms_count > 0 ? Math.min(100, Math.round((physicalReservations.length / totalPhysicalCapacityMonth) * 100)) : 0;
|
|
const pTodayRes = physicalReservations.filter(r => r.start_time && r.start_time.startsWith(todayStr)).length;
|
|
const pWeekRes = physicalReservations.filter(r => {
|
|
if (!r.start_time) return false;
|
|
return new Date(r.start_time) >= startOfWeek;
|
|
}).length;
|
|
const avg_day_pct = physical_rooms_count > 0 ? Math.min(100, Math.round((pTodayRes / Math.max(1, physical_rooms_count * 3)) * 100)) : 0;
|
|
const avg_week_pct = physical_rooms_count > 0 ? Math.min(100, Math.round((pWeekRes / totalPhysicalCapacityMonth) * 100)) : 0;
|
|
|
|
// Top y Low rooms reales
|
|
const roomReservationsCount = {};
|
|
physicalReservations.forEach(r => {
|
|
roomReservationsCount[r.classroom_id] = (roomReservationsCount[r.classroom_id] || 0) + 1;
|
|
});
|
|
|
|
const calculatedRooms = physicalRooms.map(c => {
|
|
const rawFloor = c.floor !== null && c.floor !== undefined ? String(c.floor).trim() : '0';
|
|
let floor_display = rawFloor;
|
|
if (rawFloor === '0' || rawFloor.toUpperCase() === 'PB' || rawFloor.toLowerCase().includes('baja')) {
|
|
floor_display = 'PB';
|
|
} else if (!isNaN(rawFloor) && !rawFloor.toLowerCase().includes('piso')) {
|
|
floor_display = `Piso ${rawFloor}`;
|
|
}
|
|
const count = roomReservationsCount[c.id] || 0;
|
|
const month_pct = Math.min(100, Math.round((count / 15) * 100));
|
|
return {
|
|
classroom: {
|
|
id: c.id,
|
|
code: c.code || c.name || `Aula ${c.id}`,
|
|
floor_display: floor_display,
|
|
capacity: c.capacity || 30
|
|
},
|
|
month_count: count,
|
|
month_pct: month_pct
|
|
};
|
|
});
|
|
|
|
calculatedRooms.sort((a, b) => b.month_count - a.month_count);
|
|
const top_rooms = calculatedRooms.filter(r => r.month_count > 0);
|
|
if (top_rooms.length === 0 && calculatedRooms.length > 0) {
|
|
top_rooms.push(...calculatedRooms.slice(0, 4));
|
|
}
|
|
const low_rooms = [...calculatedRooms].sort((a, b) => a.month_count - b.month_count);
|
|
|
|
res.render('admin/metrics/occupancy', {
|
|
title: 'Gestión de Ocupación y Métricas - Edu-Space Admin',
|
|
physical_rooms_count,
|
|
avg_day_pct,
|
|
avg_week_pct,
|
|
avg_month_pct,
|
|
total_month_classes,
|
|
v_today,
|
|
v_week,
|
|
v_month,
|
|
shift_counts,
|
|
floor_summary,
|
|
top_rooms,
|
|
low_rooms
|
|
});
|
|
} catch (error) {
|
|
console.error('Error rendering occupancy metrics:', error.message);
|
|
res.status(500).send('Error loading occupancy metrics view');
|
|
}
|
|
};
|
|
|
|
router.get(['/occupancy_metrics', '/occupancy-metrics', '/metrics/occupancy'], handleOccupancyMetrics);
|
|
|
|
// ─── 3. USERS ─────────────────────────────────────────────────────────────────
|
|
|
|
const MOCK_ROLES = [
|
|
{ id: 1, name: 'Administrador', description: 'Acceso total al sistema', user_count: 2, is_system: true, permissions: { classrooms: 'read_write', schedule: 'read_write', admin: 'read_write', buildings: 'read_write' } },
|
|
{ id: 2, name: 'Bedel', description: 'Gestión de reservas y aulas', user_count: 5, is_system: false, permissions: { classrooms: 'read_write', schedule: 'read_write', admin: 'read', buildings: 'read' } },
|
|
{ id: 3, name: 'Docente', description: 'Visualización de horarios', user_count: 18, is_system: false, permissions: { classrooms: 'read', schedule: 'read', admin: 'none', buildings: 'read' } },
|
|
{ id: 4, name: 'Invitado', description: 'Solo lectura', user_count: 3, is_system: false, permissions: { classrooms: 'read', schedule: 'none', admin: 'none', buildings: 'none' } }
|
|
];
|
|
|
|
const MOCK_USERS = [
|
|
{ id: 1, name: 'Admin Sistema', email: 'admin@edu-space.com', role_id: 1, role: { name: 'Administrador' }, is_active: true, created_at: '2025-01-01' },
|
|
{ id: 2, name: 'María González', email: 'mgonzalez@edu-space.com', role_id: 2, role: { name: 'Bedel' }, is_active: true, created_at: '2025-03-15' },
|
|
{ id: 3, name: 'Carlos Rodríguez', email: 'crodriguez@edu-space.com', role_id: 3, role: { name: 'Docente' }, is_active: true, created_at: '2025-04-10' },
|
|
{ id: 4, name: 'Laura Martínez', email: 'lmartinez@edu-space.com', role_id: 2, role: { name: 'Bedel' }, is_active: false, created_at: '2025-05-20' }
|
|
];
|
|
|
|
const buildPagination = (page, perPage, total) => {
|
|
const pages = Math.ceil(total / perPage) || 1;
|
|
const pages_list = [];
|
|
const maxPages = 7;
|
|
let startPage = Math.max(1, page - Math.floor(maxPages / 2));
|
|
let endPage = Math.min(pages, startPage + maxPages - 1);
|
|
if (endPage - startPage + 1 < maxPages) {
|
|
startPage = Math.max(1, endPage - maxPages + 1);
|
|
}
|
|
for (let i = startPage; i <= endPage; i++) {
|
|
pages_list.push(i);
|
|
}
|
|
return {
|
|
page,
|
|
per_page: perPage,
|
|
total,
|
|
pages,
|
|
has_prev: page > 1,
|
|
has_next: page < pages,
|
|
pages_list,
|
|
iter_pages: () => pages_list
|
|
};
|
|
};
|
|
|
|
const fetchRolesAndDocs = async (apiClient) => {
|
|
let roles = [...MOCK_ROLES];
|
|
let document_types = [];
|
|
try {
|
|
const [rRes, dRes] = await Promise.allSettled([
|
|
apiClient.get('/roles'),
|
|
apiClient.get('/admin/users/document-types')
|
|
]);
|
|
if (rRes.status === 'fulfilled' && rRes.value.data) {
|
|
const d = rRes.value.data;
|
|
roles = (d.roles || d) || roles;
|
|
}
|
|
if (dRes.status === 'fulfilled' && dRes.value.data) {
|
|
document_types = dRes.value.data.document_types || [];
|
|
}
|
|
} catch (e) {
|
|
console.warn('Using mock roles data:', e.message);
|
|
}
|
|
if (!document_types || document_types.length === 0) {
|
|
document_types = [
|
|
{ code: 'DNI', name: 'Documento Nacional de Identidad', category: 'Nacional', placeholder: '8 dígitos sin puntos' },
|
|
{ code: 'CUIL', name: 'Código Único de Identificación Laboral (CUIL/CUIT)', category: 'Nacional / Laboral', placeholder: '20-12345678-9' },
|
|
{ code: 'PAS', name: 'Pasaporte Argentino', category: 'Internacional', placeholder: 'AAB123456' },
|
|
{ code: 'PASEXT', name: 'Pasaporte Extranjero', category: 'Internacional / Extranjero', placeholder: 'Alfanumérico país de origen' },
|
|
{ code: 'DNIEXT', name: 'DNI para Extranjeros (Residente)', category: 'Extranjero / Residente', placeholder: 'DNI residente' },
|
|
{ code: 'CI', name: 'Cédula de Identidad (PFA / Prov)', category: 'Nacional (Histórico)', placeholder: 'Cédula de identidad' },
|
|
{ code: 'CIEXT', name: 'Cédula de Identidad Extranjera (Mercosur)', category: 'Regional / Mercosur', placeholder: 'Cédula Mercosur' },
|
|
{ code: 'LC', name: 'Libreta Cívica', category: 'Histórico Nacional', placeholder: 'Libreta Cívica' },
|
|
{ code: 'LE', name: 'Libreta de Enrolamiento', category: 'Histórico Nacional', placeholder: 'Libreta Enrolamiento' }
|
|
];
|
|
}
|
|
return { roles, document_types };
|
|
};
|
|
|
|
const fetchUsersAndRoles = async (apiClient) => {
|
|
const { roles, document_types } = await fetchRolesAndDocs(apiClient);
|
|
return { users: [...MOCK_USERS], roles, document_types };
|
|
};
|
|
|
|
const handleUsersList = async (req, res) => {
|
|
try {
|
|
const page = parseInt(req.query.page, 10) || 1;
|
|
const per_page = 25;
|
|
const search = (req.query.search || '').trim();
|
|
const role_filter = req.query.role || '';
|
|
const status_filter = req.query.status || '';
|
|
const msg = req.query.msg || '';
|
|
const error = req.query.error || '';
|
|
|
|
let users = [];
|
|
let roles = [...MOCK_ROLES];
|
|
let document_types = [];
|
|
let total = 0;
|
|
let role_counts = {
|
|
total: 0,
|
|
active: 0,
|
|
inactive: 0,
|
|
admin: 0,
|
|
bedelia: 0,
|
|
docente: 0,
|
|
alumno: 0
|
|
};
|
|
|
|
try {
|
|
const resp = await req.apiClient.get('/admin/users', {
|
|
params: {
|
|
page,
|
|
per_page,
|
|
search: search || undefined,
|
|
role: role_filter || undefined,
|
|
status: status_filter || undefined
|
|
}
|
|
});
|
|
if (resp.data) {
|
|
users = resp.data.users || [];
|
|
roles = resp.data.roles || roles;
|
|
document_types = resp.data.document_types || [];
|
|
total = resp.data.total !== undefined ? resp.data.total : users.length;
|
|
if (resp.data.role_counts) {
|
|
role_counts = resp.data.role_counts;
|
|
}
|
|
}
|
|
} catch (apiErr) {
|
|
console.warn('Users list API notice:', apiErr.message);
|
|
}
|
|
|
|
const pagination = buildPagination(page, per_page, total);
|
|
|
|
res.render('admin/users/list', {
|
|
title: 'Gestión de Usuarios — Edu-Space Admin',
|
|
users,
|
|
roles,
|
|
document_types,
|
|
search,
|
|
role_filter,
|
|
status_filter,
|
|
pagination,
|
|
role_counts,
|
|
msg,
|
|
error
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in users list:', err.message);
|
|
res.render('admin/users/list', {
|
|
title: 'Gestión de Usuarios — Edu-Space Admin',
|
|
users: MOCK_USERS,
|
|
roles: MOCK_ROLES,
|
|
document_types: [],
|
|
search: '', role_filter: '', status_filter: '', msg: '', error: '',
|
|
pagination: buildPagination(1, 25, MOCK_USERS.length)
|
|
});
|
|
}
|
|
};
|
|
|
|
const handleUserAdd = async (req, res) => {
|
|
try {
|
|
const { roles, document_types } = await fetchRolesAndDocs(req.apiClient);
|
|
res.render('admin/users/form', {
|
|
title: 'Nuevo Usuario — Edu-Space Admin',
|
|
user: null,
|
|
roles,
|
|
document_types,
|
|
error: req.query.error || null,
|
|
msg: req.query.msg || null
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in user add:', err.message);
|
|
res.render('admin/users/form', {
|
|
title: 'Nuevo Usuario — Edu-Space Admin',
|
|
user: null,
|
|
roles: MOCK_ROLES,
|
|
document_types: [],
|
|
error: req.query.error || null,
|
|
msg: null
|
|
});
|
|
}
|
|
};
|
|
|
|
const handleUserEdit = async (req, res) => {
|
|
try {
|
|
const userId = req.params.id || req.query.id;
|
|
const { roles, document_types } = await fetchRolesAndDocs(req.apiClient);
|
|
let targetUser = null;
|
|
|
|
if (userId && req.apiClient) {
|
|
try {
|
|
const singleRes = await req.apiClient.get(`/users/${userId}`);
|
|
if (singleRes.data && (singleRes.data.user || singleRes.data.data)) {
|
|
targetUser = singleRes.data.user || singleRes.data.data;
|
|
}
|
|
} catch (e) {
|
|
console.warn(`User ${userId} not found via single endpoint:`, e.message);
|
|
}
|
|
}
|
|
|
|
targetUser = targetUser || MOCK_USERS[0];
|
|
const userName = targetUser ? (targetUser.name || `${targetUser.first_name || ''} ${targetUser.last_name || ''}`.trim() || targetUser.email || `Usuario #${targetUser.id}`) : 'Usuario';
|
|
|
|
res.render('admin/users/form', {
|
|
title: `Editar Usuario: ${userName} — Edu-Space Admin`,
|
|
user: targetUser,
|
|
roles,
|
|
document_types,
|
|
error: req.query.error || null,
|
|
msg: req.query.msg || null
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in user edit:', err.message);
|
|
res.render('admin/users/form', {
|
|
title: 'Editar Usuario — Edu-Space Admin',
|
|
user: MOCK_USERS[0],
|
|
roles: MOCK_ROLES,
|
|
document_types: [],
|
|
error: 'No se pudo cargar la información del usuario.',
|
|
msg: null
|
|
});
|
|
}
|
|
};
|
|
|
|
const handleUserSave = async (req, res) => {
|
|
const userId = req.params.id || req.body.id;
|
|
const {
|
|
name, first_name, last_name, email, personal_email, password, role_id, is_active,
|
|
phone, address, document_type, document_number
|
|
} = req.body;
|
|
|
|
const payload = {
|
|
first_name: (first_name || '').trim(),
|
|
last_name: (last_name || '').trim(),
|
|
name: (name || `${first_name || ''} ${last_name || ''}`).trim(),
|
|
email: (email || '').trim().toLowerCase(),
|
|
personal_email: (personal_email || '').trim().toLowerCase(),
|
|
phone: (phone || '').trim(),
|
|
address: (address || '').trim(),
|
|
document_type: (document_type || 'DNI').trim().toUpperCase(),
|
|
document_number: (document_number || '').trim(),
|
|
role_id: role_id ? parseInt(role_id, 10) : null,
|
|
is_active: is_active === 'on' || is_active === 'true' || is_active === true
|
|
};
|
|
if (password && password.trim()) {
|
|
if (password.trim().length < 6) {
|
|
const errMsg = encodeURIComponent('La contraseña debe tener al menos 6 caracteres.');
|
|
return res.redirect(userId ? `/admin/users/edit/${userId}?error=${errMsg}` : `/admin/user_add?error=${errMsg}`);
|
|
}
|
|
payload.password = password.trim();
|
|
}
|
|
try {
|
|
if (userId) {
|
|
await req.apiClient.put(`/users/${userId}`, payload);
|
|
} else {
|
|
await req.apiClient.post('/users', payload);
|
|
}
|
|
return res.redirect('/admin/users_list?msg=saved');
|
|
} catch (e) {
|
|
console.warn('User save API notice:', e.response?.data || e.message);
|
|
const errMsg = encodeURIComponent(e.response?.data?.message || 'Error al guardar el usuario');
|
|
return res.redirect(userId ? `/admin/users/edit/${userId}?error=${errMsg}` : `/admin/users_list?error=${errMsg}`);
|
|
}
|
|
};
|
|
|
|
const handleUserPasswordReset = async (req, res) => {
|
|
const userId = req.params.id || req.body.id || req.body.user_id;
|
|
const password = (req.body.password || req.body.new_password || '').trim();
|
|
|
|
if (!userId || !password) {
|
|
const errMsg = encodeURIComponent('Debe seleccionar un usuario e ingresar la nueva contraseña.');
|
|
return res.redirect(`/admin/users_list?error=${errMsg}`);
|
|
}
|
|
|
|
if (password.length < 6) {
|
|
const errMsg = encodeURIComponent('La nueva contraseña debe tener al menos 6 caracteres.');
|
|
return res.redirect(`/admin/users_list?error=${errMsg}`);
|
|
}
|
|
|
|
try {
|
|
await req.apiClient.post(`/users/${userId}/password`, { password });
|
|
return res.redirect('/admin/users_list?msg=password_updated');
|
|
} catch (e) {
|
|
console.warn('Password reset notice:', e.response?.data || e.message);
|
|
const errMsg = encodeURIComponent(e.response?.data?.message || 'Error al restablecer la contraseña.');
|
|
return res.redirect(`/admin/users_list?error=${errMsg}`);
|
|
}
|
|
};
|
|
|
|
router.get(['/users_list', '/users', '/user_list'], handleUsersList);
|
|
router.get(['/user_add', '/users/new'], handleUserAdd);
|
|
router.get(['/user_edit', '/user_edit/:id', '/users/edit', '/users/edit/:id'], handleUserEdit);
|
|
router.post(['/user_add', '/users/new', '/user_save', '/users/save'], handleUserSave);
|
|
router.post(['/user_edit', '/user_edit/:id', '/users/edit', '/users/edit/:id'], handleUserSave);
|
|
router.post(['/users/:id/password', '/users/password', '/user_password', '/user_password/:id', '/user_reset_password'], handleUserPasswordReset);
|
|
|
|
|
|
// ─── 4. ROLES ─────────────────────────────────────────────────────────────────
|
|
|
|
const MODULES = [
|
|
{ id: 'classrooms', name: 'Aulas', icon: 'bi-door-open' },
|
|
{ id: 'schedule', name: 'Horarios', icon: 'bi-calendar3' },
|
|
{ id: 'buildings', name: 'Edificios', icon: 'bi-buildings' },
|
|
{ id: 'admin', name: 'Admin', icon: 'bi-shield-lock' },
|
|
{ id: 'users', name: 'Usuarios', icon: 'bi-people' },
|
|
{ id: 'reports', name: 'Reportes', icon: 'bi-graph-up' }
|
|
];
|
|
|
|
const handleRolesList = async (req, res) => {
|
|
try {
|
|
const { roles } = await fetchUsersAndRoles(req.apiClient);
|
|
res.render('admin/roles/list', {
|
|
title: 'Roles y Grupos de Acceso - Edu-Space Admin',
|
|
roles,
|
|
modules: MODULES
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in roles list:', err.message);
|
|
res.render('admin/roles/list', { title: 'Roles', roles: MOCK_ROLES, modules: MODULES });
|
|
}
|
|
};
|
|
|
|
const handleRoleAdd = async (req, res) => {
|
|
res.render('admin/roles/edit', {
|
|
title: 'Nuevo Rol - Edu-Space Admin',
|
|
role: null,
|
|
current_perms: {},
|
|
modules: MODULES
|
|
});
|
|
};
|
|
|
|
const handleRoleEdit = async (req, res) => {
|
|
try {
|
|
const { roles } = await fetchUsersAndRoles(req.apiClient);
|
|
const roleId = req.params.id || req.query.id;
|
|
const targetRole = (roleId ? roles.find(r => String(r.id) === String(roleId)) : null) || roles[0] || MOCK_ROLES[0];
|
|
res.render('admin/roles/edit', {
|
|
title: `Editar Rol: ${targetRole.name} - Edu-Space Admin`,
|
|
role: targetRole,
|
|
current_perms: targetRole.permissions || {},
|
|
modules: MODULES
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in role edit:', err.message);
|
|
res.render('admin/roles/edit', { title: 'Editar Rol', role: MOCK_ROLES[0], current_perms: MOCK_ROLES[0].permissions || {}, modules: MODULES });
|
|
}
|
|
};
|
|
|
|
const handleRoleSave = async (req, res) => {
|
|
const roleId = req.params.id || req.body.id;
|
|
const { name, description, ...perms } = req.body;
|
|
const permissions = {};
|
|
MODULES.forEach(m => { permissions[m.id] = perms[`perm_${m.id}`] || 'none'; });
|
|
const payload = { name, description, permissions };
|
|
try {
|
|
if (roleId) {
|
|
await req.apiClient.put(`/roles/${roleId}`, payload);
|
|
} else {
|
|
await req.apiClient.post('/roles', payload);
|
|
}
|
|
} catch (e) {
|
|
console.warn('Role save API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect('/admin/roles_list');
|
|
};
|
|
|
|
router.get(['/roles_list', '/roles', '/role_list'], handleRolesList);
|
|
router.get(['/role_add', '/roles/new'], handleRoleAdd);
|
|
router.get(['/role_edit', '/role_edit/:id', '/roles/edit', '/roles/edit/:id'], handleRoleEdit);
|
|
router.post(['/role_add', '/roles/new', '/role_save'], handleRoleSave);
|
|
router.post(['/role_edit', '/role_edit/:id', '/roles/edit', '/roles/edit/:id'], handleRoleSave);
|
|
|
|
const handleRoleDelete = async (req, res) => {
|
|
const roleId = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.delete(`/roles/${roleId}`);
|
|
} catch (e) {
|
|
console.warn('Role delete API notice:', e.message);
|
|
}
|
|
res.redirect('/admin/roles_list');
|
|
};
|
|
router.post(['/role_delete', '/role_delete/:id', '/roles/:id/delete'], handleRoleDelete);
|
|
|
|
const handleUserToggle = async (req, res) => {
|
|
const userId = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.post(`/users/${userId}/toggle`);
|
|
} catch (e) {
|
|
console.warn('User toggle API notice:', e.message);
|
|
}
|
|
res.redirect('/admin/users_list');
|
|
};
|
|
|
|
const handleUserDelete = async (req, res) => {
|
|
const userId = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.delete(`/users/${userId}`);
|
|
} catch (e) {
|
|
console.warn('User delete API notice:', e.message);
|
|
}
|
|
res.redirect('/admin/users_list');
|
|
};
|
|
|
|
router.post(['/user_toggle', '/user_toggle/:id', '/users/:id/toggle'], handleUserToggle);
|
|
router.post(['/user_delete', '/user_delete/:id', '/users/:id/delete'], handleUserDelete);
|
|
|
|
// ─── 5. CAREERS ───────────────────────────────────────────────────────────────
|
|
|
|
const handleCareersList = async (req, res) => {
|
|
try {
|
|
const search = (req.query.search || '').trim().toLowerCase();
|
|
let careers = [];
|
|
let stats = {};
|
|
|
|
try {
|
|
const [cRes, sRes] = await Promise.allSettled([
|
|
req.apiClient.get('/careers', { params: { search } }),
|
|
req.apiClient.get('/subjects')
|
|
]);
|
|
if (cRes.status === 'fulfilled' && cRes.value.data) {
|
|
careers = cRes.value.data.careers || [];
|
|
}
|
|
const allSubjects = (sRes.status === 'fulfilled' && sRes.value.data && sRes.value.data.subjects) || [];
|
|
careers.forEach(c => {
|
|
const cSubjs = allSubjects.filter(s => s.career_id === c.id);
|
|
stats[c.id] = {
|
|
subjects_count: cSubjs.length,
|
|
commissions_count: cSubjs.reduce((acc, s) => acc + (s.commissions_count || 0), 0)
|
|
};
|
|
});
|
|
} catch (apiErr) {
|
|
console.warn('Careers list API notice:', apiErr.message);
|
|
}
|
|
|
|
res.render('admin/careers/list', {
|
|
title: 'Gestión de Carreras - Edu-Space Admin',
|
|
careers,
|
|
stats,
|
|
search,
|
|
msg: req.query.msg || '',
|
|
error: req.query.error || '',
|
|
can_edit: true
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in careers list:', err.message);
|
|
res.redirect('/admin/occupancy_metrics');
|
|
}
|
|
};
|
|
|
|
const handleCareerAdd = async (req, res) => {
|
|
const { name, code, description } = req.body;
|
|
try {
|
|
await req.apiClient.post('/careers', { name, code, description });
|
|
res.redirect('/admin/careers_list?msg=created');
|
|
} catch (e) {
|
|
console.warn('Career add API notice:', e.response?.data || e.message);
|
|
const errCode = e.response?.status === 409 ? 'conflict' : 'create';
|
|
res.redirect(`/admin/careers_list?error=${errCode}`);
|
|
}
|
|
};
|
|
|
|
const handleCareerEdit = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
const { name, code, description } = req.body;
|
|
try {
|
|
await req.apiClient.put(`/careers/${id}`, { name, code, description });
|
|
res.redirect('/admin/careers_list?msg=updated');
|
|
} catch (e) {
|
|
console.warn('Career edit API notice:', e.response?.data || e.message);
|
|
const errCode = e.response?.status === 409 ? 'conflict' : 'edit';
|
|
res.redirect(`/admin/careers_list?error=${errCode}`);
|
|
}
|
|
};
|
|
|
|
const handleCareerDelete = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.delete(`/careers/${id}`);
|
|
res.redirect('/admin/careers_list?msg=deleted');
|
|
} catch (e) {
|
|
console.warn('Career delete API notice:', e.response?.data || e.message);
|
|
const errCode = e.response?.status === 409 ? 'has_subjects' : 'delete';
|
|
res.redirect(`/admin/careers_list?error=${errCode}`);
|
|
}
|
|
};
|
|
|
|
router.get(['/careers_list', '/careers', '/career_list'], handleCareersList);
|
|
router.post(['/career_add', '/careers/add', '/careers/new'], handleCareerAdd);
|
|
router.post(['/career_edit', '/career_edit/:id', '/careers/edit/:id'], handleCareerEdit);
|
|
router.post(['/career_delete', '/career_delete/:id', '/careers/delete/:id'], handleCareerDelete);
|
|
|
|
// ─── 6. SUBJECTS ──────────────────────────────────────────────────────────────
|
|
|
|
const handleSubjectsList = async (req, res) => {
|
|
try {
|
|
const page = parseInt(req.query.page, 10) || 1;
|
|
const per_page = 25;
|
|
const search = (req.query.search || '').trim();
|
|
const career_id = req.query.career_id || '';
|
|
const active = req.query.active || '';
|
|
|
|
let subjects = [];
|
|
let careers = [];
|
|
let total = 0;
|
|
|
|
try {
|
|
const params = { page, per_page };
|
|
if (search) params.search = search;
|
|
if (career_id) params.career_id = parseInt(career_id, 10);
|
|
if (active) params.active = active;
|
|
|
|
const [sRes, cRes] = await Promise.allSettled([
|
|
req.apiClient.get('/subjects', { params }),
|
|
req.apiClient.get('/careers')
|
|
]);
|
|
if (sRes.status === 'fulfilled' && sRes.value.data) {
|
|
subjects = sRes.value.data.subjects || [];
|
|
careers = sRes.value.data.careers || [];
|
|
total = sRes.value.data.total !== undefined ? sRes.value.data.total : subjects.length;
|
|
}
|
|
if (cRes.status === 'fulfilled' && cRes.value.data && (!careers || careers.length === 0)) {
|
|
careers = cRes.value.data.careers || [];
|
|
}
|
|
} catch (apiErr) {
|
|
console.warn('Subjects list API notice:', apiErr.message);
|
|
}
|
|
|
|
const pagination = buildPagination(page, per_page, total);
|
|
|
|
res.render('admin/subjects/list', {
|
|
title: 'Gestión de Asignaturas - Edu-Space Admin',
|
|
subjects,
|
|
careers,
|
|
search,
|
|
career_filter: career_id ? parseInt(career_id, 10) : '',
|
|
active_filter: active,
|
|
can_edit: true,
|
|
msg: req.query.msg || '',
|
|
error: req.query.error || '',
|
|
pagination
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in subjects list:', err.message);
|
|
res.redirect('/admin/occupancy_metrics');
|
|
}
|
|
};
|
|
|
|
const handleSubjectAdd = async (req, res) => {
|
|
const { code, name, department, credits, career_id, description, is_active } = req.body;
|
|
try {
|
|
await req.apiClient.post('/subjects', {
|
|
code,
|
|
name,
|
|
department,
|
|
credits: parseInt(credits, 10) || 4,
|
|
career_id: career_id ? parseInt(career_id, 10) : null,
|
|
description,
|
|
is_active: is_active === 'on' || is_active === 'true' || is_active === true
|
|
});
|
|
res.redirect('/admin/subjects_list?msg=created');
|
|
} catch (e) {
|
|
console.warn('Subject add API notice:', e.response?.data || e.message);
|
|
const errCode = e.response?.status === 409 ? 'conflict' : 'create';
|
|
res.redirect(`/admin/subjects_list?error=${errCode}`);
|
|
}
|
|
};
|
|
|
|
const handleSubjectEdit = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
const { code, name, department, credits, career_id, description, is_active } = req.body;
|
|
try {
|
|
await req.apiClient.put(`/subjects/${id}`, {
|
|
code,
|
|
name,
|
|
department,
|
|
credits: parseInt(credits, 10) || 4,
|
|
career_id: career_id ? parseInt(career_id, 10) : null,
|
|
description,
|
|
is_active: is_active === 'on' || is_active === 'true' || is_active === true
|
|
});
|
|
res.redirect('/admin/subjects_list?msg=updated');
|
|
} catch (e) {
|
|
console.warn('Subject edit API notice:', e.response?.data || e.message);
|
|
const errCode = e.response?.status === 409 ? 'conflict' : 'edit';
|
|
res.redirect(`/admin/subjects_list?error=${errCode}`);
|
|
}
|
|
};
|
|
|
|
const handleSubjectToggle = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.post(`/subjects/${id}/toggle`);
|
|
res.redirect('/admin/subjects_list?msg=toggled');
|
|
} catch (e) {
|
|
console.warn('Subject toggle API notice:', e.message);
|
|
res.redirect('/admin/subjects_list?error=toggle');
|
|
}
|
|
};
|
|
|
|
const handleSubjectDelete = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
const delRes = await req.apiClient.delete(`/subjects/${id}`);
|
|
const action = delRes.data?.action || 'deleted';
|
|
return res.redirect(`/admin/subjects_list?msg=${action}`);
|
|
} catch (e) {
|
|
console.warn('Subject delete API notice:', e.response?.data || e.message);
|
|
return res.redirect('/admin/subjects_list?error=delete');
|
|
}
|
|
};
|
|
|
|
router.get(['/subjects_list', '/subjects', '/subject_list'], handleSubjectsList);
|
|
router.post(['/subject_add', '/subjects/add', '/subjects/new'], handleSubjectAdd);
|
|
router.post(['/subject_edit', '/subject_edit/:id', '/subjects/edit/:id'], handleSubjectEdit);
|
|
router.post(['/subject_toggle', '/subject_toggle/:id', '/subjects/:id/toggle'], handleSubjectToggle);
|
|
router.post(['/subject_delete', '/subject_delete/:id', '/subjects/:id/delete'], handleSubjectDelete);
|
|
|
|
// ─── 7. COMMISSIONS ───────────────────────────────────────────────────────────
|
|
|
|
const handleCommissionsList = async (req, res) => {
|
|
try {
|
|
const page = parseInt(req.query.page, 10) || 1;
|
|
const per_page = 25;
|
|
const search = (req.query.search || '').trim();
|
|
const subject_id = req.query.subject_id || '';
|
|
const career_id = req.query.career_id || '';
|
|
const shift = req.query.shift || '';
|
|
const active = req.query.active || '';
|
|
const unassigned_room = req.query.unassigned_room || '';
|
|
const created = req.query.created === '1';
|
|
|
|
let commissions = [];
|
|
let subjects = [];
|
|
let teachers = [];
|
|
let academic_terms = [];
|
|
let careers = [];
|
|
let total = 0;
|
|
|
|
try {
|
|
const params = { page, per_page };
|
|
if (search) params.search = search;
|
|
if (subject_id) params.subject_id = parseInt(subject_id, 10);
|
|
if (career_id) params.career_id = parseInt(career_id, 10);
|
|
if (shift) params.shift = shift;
|
|
if (active) params.active = active;
|
|
if (unassigned_room) params.unassigned_room = unassigned_room;
|
|
|
|
const [cRes, uRes] = await Promise.allSettled([
|
|
req.apiClient.get('/commissions', { params }),
|
|
req.apiClient.get('/admin/users/teachers')
|
|
]);
|
|
|
|
if (cRes.status === 'fulfilled' && cRes.value.data) {
|
|
total = cRes.value.data.total !== undefined ? cRes.value.data.total : (cRes.value.data.commissions || []).length;
|
|
commissions = (cRes.value.data.commissions || []).map(c => {
|
|
const subjObj = c.subject || {};
|
|
const subjName = subjObj.name || c.subject_name || 'Sin Asignatura';
|
|
const subjCode = subjObj.code || c.subject_code || '';
|
|
const carList = (c.careers && c.careers.length > 0) ? c.careers : (subjObj.careers || []);
|
|
const carName = c.career_name || subjObj.career_name || (carList.length > 0 ? carList.map(cr => cr.name).join(', ') : 'Carrera General');
|
|
|
|
return {
|
|
...c,
|
|
get_full_code: () => c.full_code || c.code,
|
|
subject_name: subjName,
|
|
subject_code: subjCode,
|
|
career_id: c.career_id || subjObj.career_id,
|
|
career_name: carName,
|
|
careers: carList,
|
|
classroom_name: c.classroom_name || 'Sin Aula Asignada',
|
|
has_classroom: Boolean(c.has_classroom),
|
|
is_virtual: Boolean(c.is_virtual),
|
|
virtual_link: c.virtual_link || '',
|
|
schedule: c.schedule || 'Sin horario',
|
|
subject: {
|
|
id: c.subject_id || subjObj.id,
|
|
name: subjName,
|
|
code: subjCode,
|
|
career_id: c.career_id || subjObj.career_id,
|
|
career_name: carName,
|
|
careers: carList
|
|
},
|
|
teacher: c.teacher_name ? { name: c.teacher_name } : null,
|
|
teachers: c.teachers || (c.teacher_name ? [{ name: c.teacher_name, role: 'Titular' }] : [])
|
|
};
|
|
});
|
|
subjects = cRes.value.data.subjects || [];
|
|
academic_terms = cRes.value.data.academic_terms || [];
|
|
careers = cRes.value.data.careers || [];
|
|
}
|
|
|
|
// Fallback robusto para subjects si no vinieron en la respuesta de commissions
|
|
if (!subjects || subjects.length === 0) {
|
|
try {
|
|
const subRes = await req.apiClient.get('/subjects', { params: { per_page: 250 } });
|
|
subjects = subRes.data?.subjects || subRes.data || [];
|
|
} catch (sErr) {
|
|
console.warn('Notice fetching subjects fallback:', sErr.message);
|
|
}
|
|
}
|
|
|
|
// Fallback para careers si no vinieron en la respuesta de commissions
|
|
if (!careers || careers.length === 0) {
|
|
try {
|
|
const carRes = await req.apiClient.get('/careers');
|
|
careers = carRes.data?.careers || [];
|
|
} catch (carErr) { }
|
|
}
|
|
|
|
// Si por alguna razón no vinieron academic_terms en commissions, intentar fallback
|
|
if (!academic_terms || academic_terms.length === 0) {
|
|
try {
|
|
const termsRes = await req.apiClient.get('/academic-terms');
|
|
academic_terms = termsRes.data?.terms || termsRes.data?.academic_terms || [];
|
|
} catch (tErr) { }
|
|
}
|
|
|
|
if (uRes.status === 'fulfilled' && uRes.value.data) {
|
|
teachers = uRes.value.data.teachers || uRes.value.data.users || [];
|
|
if (!uRes.value.data.teachers) {
|
|
teachers = teachers.filter(u => {
|
|
const r = (u.role || '').toLowerCase();
|
|
return r.includes('docent') || r.includes('prof') || r.includes('admin') || r.includes('bedel');
|
|
});
|
|
}
|
|
}
|
|
} catch (apiErr) {
|
|
console.warn('Commissions list API notice:', apiErr.message);
|
|
}
|
|
|
|
const pagination = buildPagination(page, per_page, total);
|
|
|
|
res.render('admin/commissions/list', {
|
|
title: 'Gestión de Comisiones — Edu-Space',
|
|
commissions,
|
|
subjects,
|
|
teachers,
|
|
academic_terms,
|
|
careers,
|
|
search,
|
|
subject_filter: subject_id ? parseInt(subject_id, 10) : '',
|
|
career_filter: career_id ? parseInt(career_id, 10) : '',
|
|
shift_filter: shift,
|
|
active_filter: active,
|
|
unassigned_room_filter: unassigned_room,
|
|
created,
|
|
msg: req.query.msg || (created ? 'created' : ''),
|
|
error: req.query.error || '',
|
|
can_edit: true,
|
|
pagination
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in commissions list:', err.message);
|
|
res.redirect('/admin/occupancy_metrics');
|
|
}
|
|
};
|
|
|
|
|
|
const handleCommissionDetail = async (req, res) => {
|
|
const roleStr = (req.user?.role || '').toLowerCase();
|
|
const isDocente = roleStr.includes('docent') || roleStr.includes('prof');
|
|
const isAlumno = roleStr.includes('alum') || roleStr.includes('estud');
|
|
|
|
const rawId = req.params.id || req.query.id;
|
|
if (!rawId || rawId === 'undefined' || rawId === 'null') {
|
|
if (isDocente || isAlumno) return res.redirect('/my_subjects/my_subjects_list');
|
|
return res.redirect('/admin/commissions_list');
|
|
}
|
|
|
|
const id = parseInt(rawId, 10);
|
|
if (isNaN(id)) {
|
|
if (isDocente || isAlumno) return res.redirect('/my_subjects/my_subjects_list');
|
|
return res.redirect('/admin/commissions_list');
|
|
}
|
|
|
|
// Si un docente o alumno intenta ingresar a la ruta de administración, redirigir a su vista
|
|
if (isDocente || isAlumno) {
|
|
return res.redirect(`/my_subjects/detail/${id}`);
|
|
}
|
|
|
|
try {
|
|
let commission = null;
|
|
let teachers = [];
|
|
|
|
try {
|
|
const [cRes, uRes] = await Promise.allSettled([
|
|
req.apiClient.get(`/commissions/${id}`),
|
|
req.apiClient.get('/admin/users/teachers')
|
|
]);
|
|
if (cRes.status === 'fulfilled' && cRes.value.data && cRes.value.data.commission) {
|
|
commission = cRes.value.data.commission;
|
|
}
|
|
if (uRes.status === 'fulfilled' && uRes.value.data) {
|
|
teachers = uRes.value.data.teachers || uRes.value.data.users || [];
|
|
if (!uRes.value.data.teachers) {
|
|
teachers = teachers.filter(u => {
|
|
const r = (u.role || '').toLowerCase();
|
|
return r.includes('docent') || r.includes('prof') || r.includes('admin') || r.includes('bedel');
|
|
});
|
|
}
|
|
}
|
|
} catch (apiErr) {
|
|
console.warn('Commission detail API notice:', apiErr.message);
|
|
}
|
|
|
|
if (!commission) {
|
|
return res.redirect('/admin/commissions_list?error=not_found');
|
|
}
|
|
|
|
const commObj = {
|
|
...commission,
|
|
get_full_code: () => commission.full_code || commission.code || `COM-${commission.id}`,
|
|
subject: commission.subject || {
|
|
name: commission.subject_name || 'Asignatura',
|
|
code: commission.subject_code || 'COD-01',
|
|
career_obj: { name: commission.career_name || 'Carrera General' }
|
|
},
|
|
teacher: commission.teacher_name ? { name: commission.teacher_name, email: 'docente@edu-space.com' } : null,
|
|
teachers: commission.teachers || (commission.teacher_name ? [{ name: commission.teacher_name, role: 'Titular', email: 'docente@edu-space.com' }] : [])
|
|
};
|
|
|
|
let enrollments = [];
|
|
try {
|
|
const enrRes = await req.apiClient.get(`/commissions/${id}/enrollments`);
|
|
if (enrRes.data && enrRes.data.enrollments) {
|
|
enrollments = enrRes.data.enrollments;
|
|
}
|
|
} catch (enrErr) {
|
|
console.warn('Commission enrollments API notice:', enrErr.message);
|
|
}
|
|
|
|
let students = [];
|
|
try {
|
|
const usersRes = await req.apiClient.get('/users');
|
|
const allUsers = Array.isArray(usersRes.data) ? usersRes.data : (usersRes.data.users || []);
|
|
students = allUsers.filter(u => {
|
|
const r = (u.role_name || u.role || '').toLowerCase();
|
|
return r === 'alumno' || r === 'estudiante';
|
|
});
|
|
if (students.length === 0) {
|
|
students = allUsers;
|
|
}
|
|
} catch (usersErr) {
|
|
console.warn('Students list API notice:', usersErr.message);
|
|
}
|
|
|
|
const enrolled_ids = enrollments.map(e => e.student_id);
|
|
|
|
res.render('admin/commissions/detail', {
|
|
title: `Comisión ${commObj.get_full_code()} — Edu-Space`,
|
|
commission: commObj,
|
|
teachers,
|
|
students,
|
|
enrollments,
|
|
enrolled_ids,
|
|
can_edit: true,
|
|
error: req.query.error,
|
|
success: req.query.success,
|
|
unregistered: req.query.unregistered
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in commission detail:', err.message);
|
|
res.redirect('/admin/commissions_list');
|
|
}
|
|
};
|
|
|
|
const handleCommissionAdd = async (req, res) => {
|
|
try {
|
|
const { subject_id, code, semester, year, shift, teacher_id, max_students, schedule, virtual_link, academic_term_id } = req.body;
|
|
const payload = {
|
|
subject_id: parseInt(subject_id, 10),
|
|
code: (code || '').trim(),
|
|
semester: semester || '1C',
|
|
year: year ? parseInt(year, 10) : 2026,
|
|
academic_term_id: academic_term_id ? parseInt(academic_term_id, 10) : null,
|
|
shift: shift || 'Mañana',
|
|
teacher_id: teacher_id ? parseInt(teacher_id, 10) : null,
|
|
max_students: max_students ? parseInt(max_students, 10) : 40,
|
|
schedule: (schedule || '').trim(),
|
|
virtual_link: (virtual_link || '').trim(),
|
|
active: true
|
|
};
|
|
await req.apiClient.post('/commissions', payload);
|
|
res.redirect('/admin/commissions_list?msg=created');
|
|
} catch (e) {
|
|
console.warn('Commission add API notice:', e.response?.data || e.message);
|
|
res.redirect('/admin/commissions_list?error=create');
|
|
}
|
|
};
|
|
|
|
const handleCommissionEdit = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
const { subject_id, code, semester, year, shift, teacher_id, max_students, schedule, virtual_link, academic_term_id, active } = req.body;
|
|
const payload = {
|
|
code: (code || '').trim(),
|
|
semester: semester || '1C',
|
|
year: year ? parseInt(year, 10) : 2026,
|
|
shift: shift || 'Mañana',
|
|
teacher_id: teacher_id ? parseInt(teacher_id, 10) : null,
|
|
max_students: max_students ? parseInt(max_students, 10) : 40,
|
|
schedule: (schedule || '').trim(),
|
|
virtual_link: (virtual_link || '').trim()
|
|
};
|
|
if (subject_id) payload.subject_id = parseInt(subject_id, 10);
|
|
if (academic_term_id) payload.academic_term_id = parseInt(academic_term_id, 10);
|
|
if (active !== undefined) payload.active = (active === 'on' || active === 'true' || active === true);
|
|
|
|
await req.apiClient.put(`/commissions/${id}`, payload);
|
|
res.redirect('/admin/commissions_list?msg=updated');
|
|
} catch (e) {
|
|
console.warn('Commission edit API notice:', e.response?.data || e.message);
|
|
res.redirect('/admin/commissions_list?error=edit');
|
|
}
|
|
};
|
|
|
|
const handleCommissionToggle = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.post(`/commissions/${id}/toggle`);
|
|
res.redirect('/admin/commissions_list?msg=toggled');
|
|
} catch (e) {
|
|
console.warn('Commission toggle API notice:', e.message);
|
|
res.redirect('/admin/commissions_list?error=toggle');
|
|
}
|
|
};
|
|
|
|
const handleCommissionDelete = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
const delRes = await req.apiClient.delete(`/commissions/${id}`);
|
|
const action = delRes.data?.action || 'deleted';
|
|
res.redirect(`/admin/commissions_list?msg=${action}`);
|
|
} catch (e) {
|
|
console.warn('Commission delete API notice:', e.response?.data || e.message);
|
|
res.redirect('/admin/commissions_list?error=delete');
|
|
}
|
|
};
|
|
|
|
const handleCommissionAssignTeacher = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
const { teacher_id } = req.body;
|
|
try {
|
|
await req.apiClient.post(`/commissions/${id}/assign-teacher`, { teacher_id });
|
|
} catch (e) {
|
|
console.warn('Assign teacher API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect(`/admin/commission_detail?id=${id}`);
|
|
};
|
|
|
|
const handleCommissionAddTeacher = async (req, res) => {
|
|
const id = req.params.id || req.body.id || req.body.commission_id;
|
|
const { teacher_id, role } = req.body;
|
|
try {
|
|
await req.apiClient.post(`/commissions/${id}/teachers`, {
|
|
teacher_id: parseInt(teacher_id, 10),
|
|
role: role || 'Titular'
|
|
});
|
|
} catch (e) {
|
|
console.warn('Commission add teacher API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect(`/admin/commission_detail?id=${id}`);
|
|
};
|
|
|
|
const handleCommissionRemoveTeacher = async (req, res) => {
|
|
const id = req.params.id || req.body.id || req.body.commission_id;
|
|
const teacher_id = req.params.teacher_id || req.body.teacher_id;
|
|
try {
|
|
await req.apiClient.delete(`/commissions/${id}/teachers/${teacher_id}`);
|
|
} catch (e) {
|
|
console.warn('Commission remove teacher API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect(`/admin/commission_detail?id=${id}`);
|
|
};
|
|
|
|
const handleCommissionEnrollStudent = async (req, res) => {
|
|
const id = req.params.id || req.body.id || req.body.commission_id;
|
|
const { student_id, notes, allow_same_day_exception, exception_reason } = req.body;
|
|
try {
|
|
await req.apiClient.post(`/commissions/${id}/enrollments`, {
|
|
student_id: parseInt(student_id, 10),
|
|
notes: (notes || '').trim() || null,
|
|
allow_same_day_exception: Boolean(allow_same_day_exception),
|
|
exception_reason: (exception_reason || '').trim() || null
|
|
});
|
|
res.redirect(`/admin/commission_detail?id=${id}&success=1`);
|
|
} catch (e) {
|
|
const errorMsg = encodeURIComponent(e.response?.data?.message || 'Error al matricular estudiante.');
|
|
res.redirect(`/admin/commission_detail?id=${id}&error=${errorMsg}`);
|
|
}
|
|
};
|
|
|
|
const handleCommissionUnenrollStudent = async (req, res) => {
|
|
const id = req.params.id || req.body.id || req.body.commission_id;
|
|
const student_id = req.params.student_id || req.body.student_id;
|
|
try {
|
|
await req.apiClient.delete(`/commissions/${id}/enrollments/${student_id}`);
|
|
res.redirect(`/admin/commission_detail?id=${id}&unregistered=1`);
|
|
} catch (e) {
|
|
const errorMsg = encodeURIComponent(e.response?.data?.message || 'Error al desvincular estudiante.');
|
|
res.redirect(`/admin/commission_detail?id=${id}&error=${errorMsg}`);
|
|
}
|
|
};
|
|
|
|
const handleCommissionUpdateEnrollment = async (req, res) => {
|
|
const id = req.params.id || req.body.id || req.body.commission_id;
|
|
const student_id = req.params.student_id || req.body.student_id;
|
|
const { status, notes } = req.body;
|
|
try {
|
|
await req.apiClient.put(`/commissions/${id}/enrollments/${student_id}`, {
|
|
status: status || 'activo',
|
|
notes: notes || undefined
|
|
});
|
|
res.redirect(`/admin/commission_detail?id=${id}&updated=1`);
|
|
} catch (e) {
|
|
const errorMsg = encodeURIComponent(e.response?.data?.message || 'Error al actualizar estado de matrícula.');
|
|
res.redirect(`/admin/commission_detail?id=${id}&error=${errorMsg}`);
|
|
}
|
|
};
|
|
|
|
router.get(['/commissions_list', '/commissions', '/commission_list'], handleCommissionsList);
|
|
router.get(['/commission_detail', '/commission_detail/:id', '/commissions/:id'], handleCommissionDetail);
|
|
router.post(['/commission_add', '/commissions/add'], handleCommissionAdd);
|
|
router.post(['/commission_edit', '/commission_edit/:id'], handleCommissionEdit);
|
|
router.post(['/commission_toggle', '/commission_toggle/:id'], handleCommissionToggle);
|
|
router.post(['/commission_delete', '/commission_delete/:id', '/commissions/:id/delete'], handleCommissionDelete);
|
|
router.post(['/commission_assign_teacher', '/commission_assign_teacher/:id'], handleCommissionAssignTeacher);
|
|
router.post(['/commission_add_teacher', '/commissions/:id/teachers', '/commissions/teachers/add'], handleCommissionAddTeacher);
|
|
router.post(['/commission_remove_teacher', '/commissions/:id/teachers/delete', '/commissions/teachers/remove'], handleCommissionRemoveTeacher);
|
|
router.post(['/commission_enroll_student', '/commissions/:id/enroll-student', '/commissions/enroll-student'], handleCommissionEnrollStudent);
|
|
router.post(['/commission_unenroll_student', '/commissions/:id/unenroll-student', '/commissions/unenroll-student'], handleCommissionUnenrollStudent);
|
|
router.post(['/commission_update_enrollment', '/commissions/:id/update-enrollment'], handleCommissionUpdateEnrollment);
|
|
|
|
// ─── 8. ACADEMIC TERMS ────────────────────────────────────────────────────────
|
|
|
|
const handleAcademicTermsList = async (req, res) => {
|
|
try {
|
|
let terms = [];
|
|
let stats = {};
|
|
try {
|
|
const resData = await req.apiClient.get('/academic-terms');
|
|
if (resData.data && resData.data.terms) {
|
|
terms = resData.data.terms;
|
|
terms.forEach(t => {
|
|
stats[t.id] = { commissions_count: t.commissions_count || 0 };
|
|
});
|
|
}
|
|
} catch (apiErr) {
|
|
console.warn('Academic terms API notice:', apiErr.message);
|
|
}
|
|
|
|
if (terms.length === 0) {
|
|
terms = [
|
|
{ id: 1, code: '2026-1C', name: 'Primer Cuatrimestre 2026', year: 2026, period_type: 'Primer Cuatrimestre', is_current: true, is_active: true }
|
|
];
|
|
stats[1] = { commissions_count: 24 };
|
|
}
|
|
|
|
res.render('admin/academic_terms/list', {
|
|
title: 'Gestión de Ciclo Lectivo - Edu-Space Admin',
|
|
terms,
|
|
stats,
|
|
can_edit: true
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in academic terms list:', err.message);
|
|
res.redirect('/admin/occupancy_metrics');
|
|
}
|
|
};
|
|
|
|
const handleAcademicTermAdd = async (req, res) => {
|
|
try {
|
|
await req.apiClient.post('/academic-terms', req.body);
|
|
} catch (e) {
|
|
console.warn('Academic term add API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect('/admin/academic_terms_list');
|
|
};
|
|
|
|
const handleAcademicTermEdit = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.put(`/academic-terms/${id}`, req.body);
|
|
} catch (e) {
|
|
console.warn('Academic term edit API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect('/admin/academic_terms_list');
|
|
};
|
|
|
|
const handleAcademicTermSetCurrent = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.post(`/academic-terms/${id}/set-current`);
|
|
} catch (e) {
|
|
console.warn('Academic term set current API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect('/admin/academic_terms_list');
|
|
};
|
|
|
|
const handleAcademicTermToggle = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.post(`/academic-terms/${id}/toggle`);
|
|
} catch (e) {
|
|
console.warn('Academic term toggle API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect('/admin/academic_terms_list');
|
|
};
|
|
|
|
const handleAcademicTermDelete = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.delete(`/academic-terms/${id}`);
|
|
} catch (e) {
|
|
console.warn('Academic term delete API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect('/admin/academic_terms_list');
|
|
};
|
|
|
|
router.get(['/academic_terms_list', '/academic_terms', '/academic-terms'], handleAcademicTermsList);
|
|
router.post(['/academic_term_add', '/academic-terms/add'], handleAcademicTermAdd);
|
|
router.post(['/academic_term_edit', '/academic_term_edit/:id'], handleAcademicTermEdit);
|
|
router.post(['/academic_term_set_current', '/academic_term_set_current/:id'], handleAcademicTermSetCurrent);
|
|
router.post(['/academic_term_toggle', '/academic_term_toggle/:id', '/academic-terms/toggle/:id'], handleAcademicTermToggle);
|
|
router.post(['/academic_term_delete', '/academic_term_delete/:id', '/academic-terms/delete/:id'], handleAcademicTermDelete);
|
|
|
|
// ─── 9. MILESTONE TYPES ───────────────────────────────────────────────────────
|
|
|
|
const handleMilestoneTypesList = async (req, res) => {
|
|
try {
|
|
let types = [];
|
|
try {
|
|
const resData = await req.apiClient.get('/milestone-types');
|
|
if (resData.data && resData.data.milestone_types) {
|
|
types = resData.data.milestone_types;
|
|
}
|
|
} catch (apiErr) {
|
|
console.warn('Milestone types API notice:', apiErr.message);
|
|
}
|
|
|
|
if (types.length === 0) {
|
|
types = [
|
|
{ id: 1, name: 'Primer Parcial', code: 'parcial_1', color: '#0d6efd', sort_order: 1, is_active: true, description: 'Primera instancia evaluativa parcial' },
|
|
{ id: 2, name: 'Segundo Parcial', code: 'parcial_2', color: '#198754', sort_order: 2, is_active: true, description: 'Segunda evaluación parcial' },
|
|
{ id: 3, name: 'Examen Final', code: 'final', color: '#dc3545', sort_order: 3, is_active: true, description: 'Turno de examen final ordinario' }
|
|
];
|
|
}
|
|
|
|
res.render('admin/milestone_types/list', {
|
|
title: 'Tipificaciones de Hitos Académicos - Edu-Space Admin',
|
|
types,
|
|
items: types,
|
|
milestone_types: types,
|
|
can_edit: true
|
|
});
|
|
} catch (err) {
|
|
console.error('Error in milestone types list:', err.message);
|
|
res.redirect('/admin/occupancy_metrics');
|
|
}
|
|
};
|
|
|
|
const handleMilestoneTypeAdd = async (req, res) => {
|
|
try {
|
|
await req.apiClient.post('/milestone-types', req.body);
|
|
} catch (e) {
|
|
console.warn('Milestone type add API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect('/admin/milestone_types_list');
|
|
};
|
|
|
|
const handleMilestoneTypeEdit = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.put(`/milestone-types/${id}`, req.body);
|
|
} catch (e) {
|
|
console.warn('Milestone type edit API notice:', e.response?.data || e.message);
|
|
}
|
|
res.redirect('/admin/milestone_types_list');
|
|
};
|
|
|
|
const handleMilestoneTypeToggle = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.post(`/milestone-types/${id}/toggle`);
|
|
} catch (e) {
|
|
console.warn('Milestone type toggle API notice:', e.message);
|
|
}
|
|
res.redirect('/admin/milestone_types_list');
|
|
};
|
|
|
|
const handleMilestoneTypeDelete = async (req, res) => {
|
|
const id = req.params.id || req.body.id;
|
|
try {
|
|
await req.apiClient.delete(`/milestone-types/${id}`);
|
|
} catch (e) {
|
|
console.warn('Milestone type delete API notice:', e.message);
|
|
}
|
|
res.redirect('/admin/milestone_types_list');
|
|
};
|
|
|
|
router.get(['/milestone_types_list', '/milestone-types', '/milestone_types'], handleMilestoneTypesList);
|
|
router.post(['/milestone_type_add', '/milestone-types/add'], handleMilestoneTypeAdd);
|
|
router.post(['/milestone_type_edit', '/milestone_type_edit/:id'], handleMilestoneTypeEdit);
|
|
router.post(['/milestone_type_toggle', '/milestone_type_toggle/:id'], handleMilestoneTypeToggle);
|
|
router.post(['/milestone_type_delete', '/milestone_type_delete/:id'], handleMilestoneTypeDelete);
|
|
|
|
// ─── 10. AUDIT LOGS ───────────────────────────────────────────────────────────
|
|
|
|
const handleAuditLogs = async (req, res) => {
|
|
const search = req.query.search || '';
|
|
const current_module = req.query.module || '';
|
|
const current_action = req.query.action || '';
|
|
const page = parseInt(req.query.page, 10) || 1;
|
|
|
|
try {
|
|
const resp = await req.apiClient.get('/admin/audit-logs', {
|
|
params: {
|
|
page,
|
|
per_page: 25,
|
|
search,
|
|
module: current_module,
|
|
action: current_action
|
|
}
|
|
});
|
|
|
|
const data = resp.data || {};
|
|
const audit_logs = data.logs || [];
|
|
const pagination = data.pagination || { pages: 1, page: 1, total: 0, has_prev: false, has_next: false };
|
|
|
|
// Generar lista de números de páginas para la plantilla Nunjucks
|
|
const pages_list = [];
|
|
const totalPages = pagination.pages || 1;
|
|
const maxPages = 7;
|
|
let startPage = Math.max(1, page - Math.floor(maxPages / 2));
|
|
let endPage = Math.min(totalPages, startPage + maxPages - 1);
|
|
if (endPage - startPage + 1 < maxPages) {
|
|
startPage = Math.max(1, endPage - maxPages + 1);
|
|
}
|
|
for (let i = startPage; i <= endPage; i++) {
|
|
pages_list.push(i);
|
|
}
|
|
pagination.pages_list = pages_list;
|
|
|
|
const modules = (data.modules && data.modules.length > 0) ? data.modules : ['auth', 'reservations', 'classrooms', 'buildings', 'academic', 'optimizer', 'users', 'admin'];
|
|
const actions = (data.actions && data.actions.length > 0) ? data.actions : ['LOGIN', 'LOGIN_FAILED', 'LOGOUT', 'CREATE', 'UPDATE', 'DELETE', 'CONFIRM', 'CANCEL'];
|
|
|
|
res.render('admin/audit_logs', {
|
|
title: 'Registro de Auditoría Institucional - Edu-Space Admin',
|
|
audit_logs,
|
|
logs: audit_logs,
|
|
modules,
|
|
actions,
|
|
current_module,
|
|
current_action,
|
|
search,
|
|
pagination
|
|
});
|
|
} catch (err) {
|
|
console.warn('[Admin] Error fetching audit logs from backend:', err.response?.data || err.message);
|
|
res.render('admin/audit_logs', {
|
|
title: 'Registro de Auditoría Institucional - Edu-Space Admin',
|
|
audit_logs: [],
|
|
logs: [],
|
|
modules: ['auth', 'reservations', 'classrooms', 'buildings', 'academic', 'optimizer', 'users', 'admin'],
|
|
actions: ['LOGIN', 'LOGIN_FAILED', 'LOGOUT', 'CREATE', 'UPDATE', 'DELETE', 'CONFIRM', 'CANCEL'],
|
|
current_module,
|
|
current_action,
|
|
search,
|
|
pagination: { pages: 1, page: 1, total: 0, has_prev: false, has_next: false, pages_list: [1] }
|
|
});
|
|
}
|
|
};
|
|
|
|
router.get(['/audit_logs', '/audit-logs', '/audit'], handleAuditLogs);
|
|
|
|
// ─── 11. CONFIGURACIÓN GLOBAL & MOODLE SYNC ────────────────────────────────────
|
|
|
|
const handleGlobalSettings = async (req, res) => {
|
|
let settings = {
|
|
smtp: { host: 'smtp.gmail.com', port: 587, security: 'tls' },
|
|
auth_providers: { local: true, google: false, moodle: false },
|
|
google_oauth: { allowed_domains: 'unicaba.edu.ar', callback_url: '/auth/google/callback' },
|
|
moodle: { server_url: 'http://10.0.0.207/moodle', auto_sync_enabled: true, sync_interval_minutes: 15 }
|
|
};
|
|
let demo_access_enabled = true;
|
|
let demo_accounts_active = true;
|
|
|
|
try {
|
|
const resp = await req.apiClient.get('/admin/settings/all');
|
|
if (resp.data && resp.data.settings) {
|
|
settings = resp.data.settings;
|
|
} else if (resp.data && resp.data.data) {
|
|
settings = resp.data.data;
|
|
}
|
|
} catch (e) {
|
|
console.warn('Global settings fetch notice:', e.message);
|
|
}
|
|
|
|
// Normalización robusta de auth_providers para asegurar compatibilidad total con Nunjucks
|
|
if (settings && settings.auth_providers) {
|
|
const ap = settings.auth_providers;
|
|
const isLocal = ap.local !== undefined ? Boolean(ap.local) : (ap.local_enabled !== undefined ? Boolean(ap.local_enabled) : true);
|
|
const isGoogle = ap.google !== undefined ? Boolean(ap.google) : (ap.google_enabled !== undefined ? Boolean(ap.google_enabled) : false);
|
|
const isMoodle = ap.moodle !== undefined ? Boolean(ap.moodle) : (ap.moodle_enabled !== undefined ? Boolean(ap.moodle_enabled) : false);
|
|
settings.auth_providers = {
|
|
local: isLocal,
|
|
local_enabled: isLocal,
|
|
google: isGoogle,
|
|
google_enabled: isGoogle,
|
|
moodle: isMoodle,
|
|
moodle_enabled: isMoodle
|
|
};
|
|
} else {
|
|
settings.auth_providers = {
|
|
local: true,
|
|
local_enabled: true,
|
|
google: false,
|
|
google_enabled: false,
|
|
moodle: false,
|
|
moodle_enabled: false
|
|
};
|
|
}
|
|
|
|
if (settings && settings.smtp) {
|
|
settings.smtp.password_masked = settings.smtp.password_masked || settings.smtp.password || '';
|
|
settings.smtp.from_email = settings.smtp.from_email || settings.smtp.sender_email || '';
|
|
settings.smtp.from_name = settings.smtp.from_name || settings.smtp.sender_name || 'Admin Edu-Space';
|
|
}
|
|
if (settings && settings.google_oauth) {
|
|
settings.google_oauth.client_secret_masked = settings.google_oauth.client_secret_masked || settings.google_oauth.client_secret || '';
|
|
}
|
|
if (settings && settings.moodle) {
|
|
settings.moodle.ws_token_masked = settings.moodle.ws_token_masked || settings.moodle.ws_token || '';
|
|
}
|
|
if (settings) {
|
|
settings.ui = settings.ui || { show_role_banner: true };
|
|
}
|
|
|
|
try {
|
|
const demoResp = await req.apiClient.get('/settings/demo-mode');
|
|
if (demoResp.data) {
|
|
if (demoResp.data.demo_access_enabled !== undefined) {
|
|
demo_access_enabled = Boolean(demoResp.data.demo_access_enabled);
|
|
}
|
|
if (demoResp.data.demo_accounts_active !== undefined) {
|
|
demo_accounts_active = Boolean(demoResp.data.demo_accounts_active);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
console.warn('Demo mode status fetch notice:', e.message);
|
|
}
|
|
|
|
res.render('admin/settings/global_config', {
|
|
title: 'Configuración Global del Sistema - Admin Edu-Space',
|
|
settings,
|
|
demo_access_enabled,
|
|
demo_accounts_active
|
|
});
|
|
};
|
|
|
|
router.get(['/settings', '/global-config', '/config'], handleGlobalSettings);
|
|
|
|
// Endpoint específico para alternar modo demo y cuentas default
|
|
router.post('/settings/demo-mode', async (req, res) => {
|
|
try {
|
|
const resp = await req.apiClient.post('/settings/demo-mode', req.body);
|
|
return res.status(resp.status || 200).json(resp.data);
|
|
} catch (err) {
|
|
console.error('Error in POST /admin/settings/demo-mode:', err.response?.data || err.message);
|
|
return res.status(err.response?.status || 500).json(err.response?.data || {
|
|
status: 'error',
|
|
message: 'Error al comunicarse con el servicio de configuración: ' + (err.response?.data?.message || err.message)
|
|
});
|
|
}
|
|
});
|
|
|
|
// Endpoint explícito para consultar y actualizar métodos de autenticación
|
|
router.get('/settings/auth-providers', async (req, res) => {
|
|
try {
|
|
const resp = await req.apiClient.get('/settings/all');
|
|
const ap = resp.data?.settings?.auth_providers || resp.data?.data?.auth_providers || {};
|
|
return res.json({
|
|
status: 'success',
|
|
auth_providers: {
|
|
local: ap.local !== undefined ? Boolean(ap.local) : (ap.local_enabled !== undefined ? Boolean(ap.local_enabled) : true),
|
|
google: ap.google !== undefined ? Boolean(ap.google) : (ap.google_enabled !== undefined ? Boolean(ap.google_enabled) : false),
|
|
moodle: ap.moodle !== undefined ? Boolean(ap.moodle) : (ap.moodle_enabled !== undefined ? Boolean(ap.moodle_enabled) : false)
|
|
}
|
|
});
|
|
} catch (err) {
|
|
return res.status(500).json({ status: 'error', message: err.message });
|
|
}
|
|
});
|
|
|
|
router.post('/settings/auth-providers', async (req, res) => {
|
|
try {
|
|
const resp = await req.apiClient.post('/settings/auth-providers', req.body);
|
|
return res.status(resp.status || 200).json(resp.data);
|
|
} catch (err) {
|
|
console.error('Error in POST /admin/settings/auth-providers:', err.response?.data || err.message);
|
|
return res.status(err.response?.status || 500).json(err.response?.data || {
|
|
status: 'error',
|
|
message: 'Error al actualizar métodos de autenticación: ' + (err.response?.data?.message || err.message)
|
|
});
|
|
}
|
|
});
|
|
|
|
// Función forwarder para acciones de configuración hacia Flask
|
|
const forwardSettingsAction = async (req, res) => {
|
|
try {
|
|
const relativeUrl = req.originalUrl.replace(/^\/admin/, '');
|
|
const resp = await req.apiClient({
|
|
method: req.method,
|
|
url: relativeUrl,
|
|
data: req.body,
|
|
params: req.query
|
|
});
|
|
return res.status(resp.status).json(resp.data);
|
|
} catch (err) {
|
|
console.error(`Error in settings proxy (${req.method} ${req.originalUrl}):`, err.response?.data || err.message);
|
|
return res.status(err.response?.status || 500).json(err.response?.data || {
|
|
status: 'error',
|
|
message: err.response?.data?.message || err.message
|
|
});
|
|
}
|
|
};
|
|
|
|
router.post('/settings/smtp', forwardSettingsAction);
|
|
router.post('/settings/smtp/test', forwardSettingsAction);
|
|
router.post('/settings/google-oauth', forwardSettingsAction);
|
|
router.post('/settings/moodle', forwardSettingsAction);
|
|
router.post('/settings/moodle/test', forwardSettingsAction);
|
|
router.post('/settings/moodle/sync', forwardSettingsAction);
|
|
router.get('/settings/moodle/stats', forwardSettingsAction);
|
|
router.post('/settings/ui', forwardSettingsAction);
|
|
router.post('/settings/reset_system', forwardSettingsAction);
|
|
router.post('/system/reset', forwardSettingsAction);
|
|
|
|
module.exports = router;
|