470 lines
17 KiB
TypeScript
470 lines
17 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server';
|
|
import * as XLSX from 'xlsx';
|
|
import supabase from '@/lib/db';
|
|
|
|
export async function POST(request: NextRequest) {
|
|
try {
|
|
const formData = await request.formData();
|
|
const file = formData.get('file') as File;
|
|
|
|
if (!file) {
|
|
return NextResponse.json({ message: 'File tidak ditemukan' }, { status: 400 });
|
|
}
|
|
|
|
let validData = [];
|
|
let errors: string[] = [];
|
|
|
|
if (file.name.endsWith('.csv') || file.type === 'text/csv') {
|
|
const fileContent = await file.text();
|
|
const result = await processCSVData(fileContent);
|
|
validData = result.validData;
|
|
errors = result.errors;
|
|
} else {
|
|
const fileBuffer = await file.arrayBuffer();
|
|
const result = await processExcelData(fileBuffer);
|
|
validData = result.validData;
|
|
errors = result.errors;
|
|
}
|
|
|
|
if (validData.length === 0) {
|
|
return NextResponse.json({
|
|
message: 'Tidak ada data valid yang ditemukan dalam file',
|
|
errors
|
|
}, { status: 400 });
|
|
}
|
|
|
|
const { imported, errorCount, errorMessages } = await insertDataToDatabase(validData);
|
|
const allErrors = [...errors, ...errorMessages];
|
|
|
|
return NextResponse.json({
|
|
message: 'Upload berhasil',
|
|
imported,
|
|
errors: errorCount,
|
|
errorDetails: allErrors.length > 0 ? allErrors : undefined
|
|
});
|
|
} catch (error) {
|
|
console.error('Error uploading file:', error);
|
|
return NextResponse.json(
|
|
{ message: `Terjadi kesalahan: ${(error as Error).message}` },
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
}
|
|
|
|
async function processExcelData(fileBuffer: ArrayBuffer) {
|
|
try {
|
|
const workbook = XLSX.read(fileBuffer, {
|
|
type: 'array',
|
|
cellDates: true,
|
|
dateNF: 'yyyy-mm-dd'
|
|
});
|
|
const sheetName = workbook.SheetNames[0];
|
|
const worksheet = workbook.Sheets[sheetName];
|
|
|
|
let jsonData = XLSX.utils.sheet_to_json(worksheet, {
|
|
header: 1,
|
|
raw: false,
|
|
dateNF: 'yyyy-mm-dd'
|
|
}) as any[][];
|
|
|
|
if (jsonData.length === 0) {
|
|
return { validData: [], errors: ['File Excel kosong'] };
|
|
}
|
|
|
|
jsonData = jsonData.map(row => {
|
|
if (!row) return row;
|
|
return row.map(cell => {
|
|
if (cell && typeof cell === 'object' && 'toISOString' in cell) {
|
|
return cell.toISOString().split('T')[0];
|
|
}
|
|
return cell;
|
|
});
|
|
});
|
|
|
|
const headers = jsonData[0].map(h => String(h).toLowerCase());
|
|
const rows = jsonData.slice(1);
|
|
|
|
return processData(headers, rows);
|
|
} catch (error) {
|
|
return { validData: [], errors: [(error as Error).message] };
|
|
}
|
|
}
|
|
|
|
async function processCSVData(fileContent: string) {
|
|
const lines = fileContent.split(/\r?\n/).filter(line => line.trim() !== '');
|
|
|
|
if (lines.length === 0) {
|
|
return { validData: [], errors: ['File CSV kosong'] };
|
|
}
|
|
|
|
const headerLine = lines[0].toLowerCase();
|
|
const headers = headerLine.split(',').map(h => h.trim());
|
|
const rows = lines.slice(1).map(line => line.split(',').map(v => v.trim()));
|
|
|
|
return processData(headers, rows);
|
|
}
|
|
|
|
function processData(headers: string[], rows: any[][]) {
|
|
const expectedHeaderMap = {
|
|
nim: ['nim', 'nomor induk', 'nomor mahasiswa'],
|
|
jenis_prestasi: ['jenis prestasi', 'jenis_prestasi', 'jenisprestasi'],
|
|
nama_prestasi: ['nama prestasi', 'nama_prestasi', 'namaprestasi', 'prestasi'],
|
|
tingkat_prestasi: ['tingkat prestasi', 'tingkat_prestasi', 'tingkatprestasi', 'tingkat'],
|
|
peringkat: ['peringkat', 'ranking', 'juara', 'posisi'],
|
|
tanggal_prestasi: ['tanggal prestasi', 'tanggal_prestasi', 'tanggalprestasi', 'tanggal']
|
|
};
|
|
|
|
const headerMap: { [key: string]: number } = {};
|
|
|
|
for (const [expectedHeader, variations] of Object.entries(expectedHeaderMap)) {
|
|
const index = headers.findIndex(h => {
|
|
if (!h) return false;
|
|
const headerStr = String(h).toLowerCase().trim();
|
|
return variations.some(variation => headerStr === variation);
|
|
});
|
|
|
|
if (index !== -1) {
|
|
headerMap[expectedHeader] = index;
|
|
}
|
|
}
|
|
|
|
for (const [expectedHeader, variations] of Object.entries(expectedHeaderMap)) {
|
|
if (headerMap[expectedHeader] !== undefined) continue;
|
|
|
|
const index = headers.findIndex(h => {
|
|
if (!h) return false;
|
|
const headerStr = String(h).toLowerCase().trim();
|
|
return variations.some(variation => headerStr.includes(variation));
|
|
});
|
|
|
|
if (index !== -1) {
|
|
headerMap[expectedHeader] = index;
|
|
}
|
|
}
|
|
|
|
const requiredHeaders = ['nim', 'jenis_prestasi', 'nama_prestasi', 'tingkat_prestasi', 'peringkat', 'tanggal_prestasi'];
|
|
const missingHeaders = requiredHeaders.filter(h => headerMap[h] === undefined);
|
|
|
|
if (missingHeaders.length > 0) {
|
|
return {
|
|
validData: [],
|
|
errors: [`Kolom berikut tidak ditemukan: ${missingHeaders.join(', ')}. Pastikan file memiliki kolom: NIM, Jenis Prestasi, Nama Prestasi, Tingkat Prestasi, Peringkat, dan Tanggal.`]
|
|
};
|
|
}
|
|
|
|
const validData = [];
|
|
const errors = [];
|
|
const validJenisPrestasi = ['Akademik', 'Non-Akademik'];
|
|
const validTingkatPrestasi = ['Kabupaten', 'Provinsi', 'Nasional', 'Internasional'];
|
|
|
|
for (let i = 0; i < rows.length; i++) {
|
|
const values = rows[i];
|
|
if (!values || values.length === 0) continue;
|
|
|
|
try {
|
|
const nim = String(values[headerMap.nim] || '').trim();
|
|
let jenis_prestasi = String(values[headerMap.jenis_prestasi] || '').trim();
|
|
const nama_prestasi = String(values[headerMap.nama_prestasi] || '').trim();
|
|
let tingkat_prestasi = String(values[headerMap.tingkat_prestasi] || '').trim();
|
|
const peringkat = String(values[headerMap.peringkat] || '').trim();
|
|
let tanggal_prestasi = String(values[headerMap.tanggal_prestasi] || '').trim();
|
|
|
|
if (!nim || !jenis_prestasi || !nama_prestasi || !tingkat_prestasi || !peringkat || !tanggal_prestasi) {
|
|
const errorMsg = `Baris ${i+2}: Data tidak lengkap (NIM: ${nim || 'kosong'})`;
|
|
errors.push(errorMsg);
|
|
continue;
|
|
}
|
|
|
|
jenis_prestasi = normalizeJenisPrestasi(jenis_prestasi);
|
|
|
|
if (!validJenisPrestasi.includes(jenis_prestasi)) {
|
|
const errorMsg = `Baris ${i+2}: Jenis prestasi tidak valid "${jenis_prestasi}" untuk NIM ${nim}. Harus salah satu dari: ${validJenisPrestasi.join(', ')}`;
|
|
errors.push(errorMsg);
|
|
continue;
|
|
}
|
|
|
|
tingkat_prestasi = normalizeTingkatPrestasi(tingkat_prestasi);
|
|
|
|
if (!validTingkatPrestasi.includes(tingkat_prestasi)) {
|
|
const errorMsg = `Baris ${i+2}: Tingkat prestasi tidak valid "${tingkat_prestasi}" untuk NIM ${nim}. Harus salah satu dari: ${validTingkatPrestasi.join(', ')}`;
|
|
errors.push(errorMsg);
|
|
continue;
|
|
}
|
|
|
|
const datePattern = /^\d{4}-\d{2}-\d{2}$/;
|
|
if (!datePattern.test(tanggal_prestasi)) {
|
|
try {
|
|
const ddmmyyyyPattern = /^(\d{1,2})-(\d{1,2})-(\d{4})$/;
|
|
const ddmmyyyyMatch = tanggal_prestasi.match(ddmmyyyyPattern);
|
|
|
|
const ddmmyyyySlashPattern = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/;
|
|
const ddmmyyyySlashMatch = tanggal_prestasi.match(ddmmyyyySlashPattern);
|
|
|
|
if (ddmmyyyyMatch) {
|
|
const day = ddmmyyyyMatch[1].padStart(2, '0');
|
|
const month = ddmmyyyyMatch[2].padStart(2, '0');
|
|
const year = ddmmyyyyMatch[3];
|
|
|
|
if (parseInt(year) < 1900 || parseInt(year) > 2100) {
|
|
const errorMsg = `Baris ${i+2}: Tahun tidak valid "${year}" untuk NIM ${nim}. Tahun harus antara 1900-2100`;
|
|
errors.push(errorMsg);
|
|
continue;
|
|
}
|
|
|
|
tanggal_prestasi = `${year}-${month}-${day}`;
|
|
}
|
|
else if (ddmmyyyySlashMatch) {
|
|
const day = ddmmyyyySlashMatch[1].padStart(2, '0');
|
|
const month = ddmmyyyySlashMatch[2].padStart(2, '0');
|
|
const year = ddmmyyyySlashMatch[3];
|
|
|
|
if (parseInt(year) < 1900 || parseInt(year) > 2100) {
|
|
const errorMsg = `Baris ${i+2}: Tahun tidak valid "${year}" untuk NIM ${nim}. Tahun harus antara 1900-2100`;
|
|
errors.push(errorMsg);
|
|
continue;
|
|
}
|
|
|
|
tanggal_prestasi = `${year}-${month}-${day}`;
|
|
}
|
|
else {
|
|
const numericValue = Number(tanggal_prestasi);
|
|
if (!isNaN(numericValue)) {
|
|
let dateObj;
|
|
|
|
if (numericValue > 60) {
|
|
const adjustedValue = numericValue - 1;
|
|
const daysToMs = adjustedValue * 24 * 60 * 60 * 1000;
|
|
dateObj = new Date(new Date(1899, 11, 30).getTime() + daysToMs);
|
|
} else {
|
|
const daysToMs = numericValue * 24 * 60 * 60 * 1000;
|
|
dateObj = new Date(new Date(1899, 11, 30).getTime() + daysToMs);
|
|
}
|
|
|
|
if (isValidDate(dateObj)) {
|
|
tanggal_prestasi = dateObj.toISOString().split('T')[0];
|
|
} else {
|
|
const errorMsg = `Baris ${i+2}: Format tanggal tidak valid "${tanggal_prestasi}" untuk NIM ${nim}. Tahun harus antara 1900-2100`;
|
|
errors.push(errorMsg);
|
|
continue;
|
|
}
|
|
} else {
|
|
const dateObj = new Date(tanggal_prestasi);
|
|
if (!isValidDate(dateObj)) {
|
|
const errorMsg = `Baris ${i+2}: Format tanggal tidak valid "${tanggal_prestasi}" untuk NIM ${nim}. Gunakan format DD-MM-YYYY, DD/MM/YYYY, atau YYYY-MM-DD`;
|
|
errors.push(errorMsg);
|
|
continue;
|
|
}
|
|
tanggal_prestasi = dateObj.toISOString().split('T')[0];
|
|
}
|
|
}
|
|
} catch (e) {
|
|
const errorMsg = `Baris ${i+2}: Format tanggal tidak valid "${tanggal_prestasi}" untuk NIM ${nim}. Gunakan format DD-MM-YYYY, DD/MM/YYYY, atau YYYY-MM-DD`;
|
|
errors.push(errorMsg);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
validData.push({
|
|
nim,
|
|
jenis_prestasi,
|
|
nama_prestasi,
|
|
tingkat_prestasi,
|
|
peringkat,
|
|
tanggal_prestasi,
|
|
keterangan: null
|
|
});
|
|
|
|
} catch (error) {
|
|
const errorMsg = `Baris ${i+2}: Error memproses data - ${(error as Error).message}`;
|
|
errors.push(errorMsg);
|
|
}
|
|
}
|
|
|
|
return { validData, errors };
|
|
}
|
|
|
|
function normalizeJenisPrestasi(value: string): string {
|
|
const lowerValue = value.toLowerCase();
|
|
|
|
if (['akademik', 'academic', 'akademis', 'a'].includes(lowerValue)) {
|
|
return 'Akademik';
|
|
}
|
|
|
|
if (['non-akademik', 'non akademik', 'nonakademik', 'non academic', 'na', 'n'].includes(lowerValue)) {
|
|
return 'Non-Akademik';
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
function normalizeTingkatPrestasi(value: string): string {
|
|
const lowerValue = value.toLowerCase();
|
|
|
|
if (['kabupaten', 'kota', 'city', 'kab', 'k'].includes(lowerValue)) {
|
|
return 'Kabupaten';
|
|
}
|
|
|
|
if (['provinsi', 'province', 'prov', 'p'].includes(lowerValue)) {
|
|
return 'Provinsi';
|
|
}
|
|
|
|
if (['nasional', 'national', 'nas', 'n'].includes(lowerValue)) {
|
|
return 'Nasional';
|
|
}
|
|
|
|
if (['internasional', 'international', 'int', 'i'].includes(lowerValue)) {
|
|
return 'Internasional';
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
function isValidDate(date: Date): boolean {
|
|
return !isNaN(date.getTime()) &&
|
|
date.getFullYear() >= 1900 &&
|
|
date.getFullYear() <= 2100;
|
|
}
|
|
|
|
async function insertDataToDatabase(data: any[]) {
|
|
let imported = 0;
|
|
let errorCount = 0;
|
|
const errorMessages: string[] = [];
|
|
|
|
console.log('=== DEBUG: Starting prestasi data insertion process ===');
|
|
console.log(`Total data items to process: ${data.length}`);
|
|
console.log('Sample data items:', data.slice(0, 3));
|
|
|
|
// First, validate all NIMs exist before processing
|
|
const uniqueNims = [...new Set(data.map(item => item.nim))];
|
|
console.log(`Unique NIMs found: ${uniqueNims.length}`);
|
|
console.log('Unique NIMs:', uniqueNims);
|
|
|
|
const nimValidationMap = new Map();
|
|
|
|
// Batch check all NIMs for existence
|
|
console.log('=== DEBUG: Starting NIM validation ===');
|
|
for (const nim of uniqueNims) {
|
|
try {
|
|
console.log(`Checking NIM: ${nim}`);
|
|
const { data: mahasiswaData, error: checkError } = await supabase
|
|
.from('mahasiswa')
|
|
.select('id_mahasiswa, nama')
|
|
.eq('nim', nim)
|
|
.single();
|
|
|
|
if (checkError || !mahasiswaData) {
|
|
console.log(`❌ NIM ${nim}: NOT FOUND in database`);
|
|
console.log(`Error details:`, checkError);
|
|
nimValidationMap.set(nim, { exists: false, error: 'Mahasiswa dengan NIM ini tidak ditemukan dalam database' });
|
|
} else {
|
|
console.log(`✅ NIM ${nim}: FOUND - ID: ${mahasiswaData.id_mahasiswa}, Nama: ${mahasiswaData.nama}`);
|
|
nimValidationMap.set(nim, { exists: true, id_mahasiswa: mahasiswaData.id_mahasiswa, nama: mahasiswaData.nama });
|
|
}
|
|
} catch (error) {
|
|
console.log(`❌ NIM ${nim}: ERROR during validation`);
|
|
console.log(`Error details:`, error);
|
|
nimValidationMap.set(nim, { exists: false, error: `Error checking NIM: ${(error as Error).message}` });
|
|
}
|
|
}
|
|
|
|
console.log('=== DEBUG: NIM validation results ===');
|
|
console.log('Validation map:', Object.fromEntries(nimValidationMap));
|
|
|
|
// Process each data item
|
|
console.log('=== DEBUG: Starting prestasi data processing ===');
|
|
for (const item of data) {
|
|
try {
|
|
console.log(`\n--- Processing prestasi item: NIM ${item.nim} ---`);
|
|
console.log('Item data:', item);
|
|
|
|
const nimValidation = nimValidationMap.get(item.nim);
|
|
console.log('NIM validation result:', nimValidation);
|
|
|
|
if (!nimValidation || !nimValidation.exists) {
|
|
errorCount++;
|
|
const errorMsg = nimValidation?.error || `NIM ${item.nim}: Mahasiswa dengan NIM ini tidak ditemukan dalam database`;
|
|
console.log(`❌ Skipping item - ${errorMsg}`);
|
|
errorMessages.push(errorMsg);
|
|
continue;
|
|
}
|
|
|
|
console.log(`✅ NIM ${item.nim} is valid, proceeding with prestasi check/insert`);
|
|
|
|
// Check if prestasi already exists for this mahasiswa
|
|
console.log(`Checking existing prestasi for mahasiswa ID: ${nimValidation.id_mahasiswa}, nama_prestasi: ${item.nama_prestasi}, tanggal: ${item.tanggal_prestasi}`);
|
|
const { data: existingPrestasi, error: prestasiCheckError } = await supabase
|
|
.from('prestasi_mahasiswa')
|
|
.select('id_prestasi')
|
|
.eq('id_mahasiswa', nimValidation.id_mahasiswa)
|
|
.eq('nama_prestasi', item.nama_prestasi)
|
|
.eq('tanggal_prestasi', item.tanggal_prestasi)
|
|
.single();
|
|
|
|
if (prestasiCheckError && prestasiCheckError.code !== 'PGRST116') {
|
|
console.log(`❌ Error checking existing prestasi:`, prestasiCheckError);
|
|
}
|
|
|
|
if (existingPrestasi) {
|
|
console.log(`📝 Updating existing prestasi (ID: ${existingPrestasi.id_prestasi})`);
|
|
// Update existing prestasi
|
|
const { error: updateError } = await supabase
|
|
.from('prestasi_mahasiswa')
|
|
.update({
|
|
jenis_prestasi: item.jenis_prestasi,
|
|
tingkat_prestasi: item.tingkat_prestasi,
|
|
peringkat: item.peringkat,
|
|
keterangan: item.keterangan || null
|
|
})
|
|
.eq('id_prestasi', existingPrestasi.id_prestasi);
|
|
|
|
if (updateError) {
|
|
errorCount++;
|
|
const errorMsg = `NIM ${item.nim} (${nimValidation.nama}): Gagal memperbarui prestasi: ${updateError.message}`;
|
|
console.log(`❌ Update failed: ${errorMsg}`);
|
|
errorMessages.push(errorMsg);
|
|
continue;
|
|
} else {
|
|
console.log(`✅ Prestasi updated successfully`);
|
|
}
|
|
} else {
|
|
console.log(`📝 Inserting new prestasi for mahasiswa ID: ${nimValidation.id_mahasiswa}`);
|
|
// Insert new prestasi
|
|
const { error: insertError } = await supabase
|
|
.from('prestasi_mahasiswa')
|
|
.insert({
|
|
id_mahasiswa: nimValidation.id_mahasiswa,
|
|
jenis_prestasi: item.jenis_prestasi,
|
|
nama_prestasi: item.nama_prestasi,
|
|
tingkat_prestasi: item.tingkat_prestasi,
|
|
peringkat: item.peringkat,
|
|
tanggal_prestasi: item.tanggal_prestasi,
|
|
keterangan: item.keterangan || null
|
|
});
|
|
|
|
if (insertError) {
|
|
errorCount++;
|
|
const errorMsg = `NIM ${item.nim} (${nimValidation.nama}): Gagal menyimpan prestasi: ${insertError.message}`;
|
|
console.log(`❌ Insert failed: ${errorMsg}`);
|
|
errorMessages.push(errorMsg);
|
|
continue;
|
|
} else {
|
|
console.log(`✅ Prestasi inserted successfully`);
|
|
}
|
|
}
|
|
|
|
imported++;
|
|
console.log(`✅ Item processed successfully. Imported count: ${imported}`);
|
|
} catch (error) {
|
|
console.error(`❌ Error processing record for NIM ${item.nim}:`, error);
|
|
errorCount++;
|
|
errorMessages.push(`NIM ${item.nim}: Terjadi kesalahan: ${(error as Error).message}`);
|
|
}
|
|
}
|
|
|
|
console.log('=== DEBUG: Final results ===');
|
|
console.log(`Total imported: ${imported}`);
|
|
console.log(`Total errors: ${errorCount}`);
|
|
console.log(`Error messages:`, errorMessages);
|
|
|
|
return { imported, errorCount, errorMessages };
|
|
} |