374 lines
13 KiB
TypeScript
374 lines
13 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 {
|
|
// Get form data from request
|
|
const formData = await request.formData();
|
|
const file = formData.get('file') as File;
|
|
|
|
if (!file) {
|
|
return NextResponse.json({ message: 'File tidak ditemukan' }, { status: 400 });
|
|
}
|
|
|
|
// Process file data based on file type
|
|
let validData = [];
|
|
let errors: string[] = [];
|
|
|
|
if (file.name.endsWith('.csv') || file.type === 'text/csv') {
|
|
// Process as CSV
|
|
const fileContent = await file.text();
|
|
const result = await processCSVData(fileContent);
|
|
validData = result.validData;
|
|
errors = result.errors;
|
|
} else {
|
|
// Process as Excel
|
|
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 });
|
|
}
|
|
|
|
// Insert valid data into the database
|
|
const { imported, errorCount, errorMessages } = await insertDataToDatabase(validData);
|
|
|
|
// Combine all error messages
|
|
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 }
|
|
);
|
|
}
|
|
}
|
|
|
|
// Function to process Excel data
|
|
async function processExcelData(fileBuffer: ArrayBuffer) {
|
|
try {
|
|
// Parse Excel file
|
|
const workbook = XLSX.read(fileBuffer, { type: 'array' });
|
|
|
|
// Get first sheet
|
|
const sheetName = workbook.SheetNames[0];
|
|
const worksheet = workbook.Sheets[sheetName];
|
|
|
|
// Convert to JSON with proper typing
|
|
const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 }) as any[][];
|
|
|
|
if (jsonData.length === 0) {
|
|
return { validData: [], errors: ['File Excel kosong'] };
|
|
}
|
|
|
|
// Convert Excel data to CSV-like format for processing
|
|
const headers = jsonData[0].map(h => String(h).toLowerCase());
|
|
const rows = jsonData.slice(1);
|
|
|
|
// Process the data using the common function
|
|
return processData(headers, rows);
|
|
} catch (error) {
|
|
console.error('Error processing Excel data:', error);
|
|
return { validData: [], errors: [(error as Error).message] };
|
|
}
|
|
}
|
|
|
|
// Function to process CSV data
|
|
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'] };
|
|
}
|
|
|
|
// Get headers from first line
|
|
const headerLine = lines[0].toLowerCase();
|
|
const headers = headerLine.split(',').map(h => h.trim());
|
|
|
|
// Process data rows
|
|
const rows = lines.slice(1).map(line => line.split(',').map(v => v.trim()));
|
|
|
|
return processData(headers, rows);
|
|
}
|
|
|
|
// Common function to process data regardless of source format
|
|
function processData(headers: string[], rows: any[][]) {
|
|
// Define expected headers and their possible variations
|
|
const expectedHeaderMap = {
|
|
nim: ['nim', 'nomor induk', 'nomor mahasiswa'],
|
|
nama_beasiswa: ['nama_beasiswa', 'nama beasiswa', 'namabeasiswa', 'beasiswa', 'nama'],
|
|
sumber_beasiswa: ['sumber_beasiswa', 'sumber beasiswa', 'sumberbeasiswa', 'sumber'],
|
|
beasiswa_status: ['beasiswa_status', 'status beasiswa', 'statusbeasiswa', 'status'],
|
|
jenis_beasiswa: ['jenis_beasiswa', 'jenis beasiswa', 'jenisbeasiswa', 'jenis']
|
|
};
|
|
|
|
// Map actual headers to expected headers
|
|
const headerMap: { [key: string]: number } = {};
|
|
for (const [expectedHeader, variations] of Object.entries(expectedHeaderMap)) {
|
|
const index = headers.findIndex(h =>
|
|
variations.some(variation => h.includes(variation))
|
|
);
|
|
if (index !== -1) {
|
|
headerMap[expectedHeader] = index;
|
|
}
|
|
}
|
|
|
|
// Check required headers
|
|
const requiredHeaders = ['nim', 'nama_beasiswa', 'sumber_beasiswa', 'beasiswa_status', 'jenis_beasiswa'];
|
|
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, Nama Beasiswa, Sumber Beasiswa, Status Beasiswa, dan Jenis Beasiswa.`]
|
|
};
|
|
}
|
|
|
|
const validData = [];
|
|
const errors = [];
|
|
const validStatuses = ['Aktif', 'Selesai', 'Dibatalkan'];
|
|
const validJenis = ['Pemerintah', 'Non-Pemerintah'];
|
|
|
|
// Process data rows
|
|
for (let i = 0; i < rows.length; i++) {
|
|
const values = rows[i];
|
|
if (!values || values.length === 0) continue;
|
|
|
|
try {
|
|
// Extract values using header map
|
|
const nim = String(values[headerMap.nim] || '').trim();
|
|
const nama_beasiswa = String(values[headerMap.nama_beasiswa] || '').trim();
|
|
const sumber_beasiswa = String(values[headerMap.sumber_beasiswa] || '').trim();
|
|
let beasiswa_status = String(values[headerMap.beasiswa_status] || '').trim();
|
|
let jenis_beasiswa = String(values[headerMap.jenis_beasiswa] || '').trim();
|
|
|
|
// Validate required fields
|
|
if (!nim || !nama_beasiswa || !sumber_beasiswa || !beasiswa_status || !jenis_beasiswa) {
|
|
errors.push(`Baris ${i+2}: Data tidak lengkap (NIM: ${nim || 'kosong'})`);
|
|
continue;
|
|
}
|
|
|
|
// Normalize status beasiswa
|
|
beasiswa_status = normalizeBeasiswaStatus(beasiswa_status);
|
|
|
|
// Validate status beasiswa
|
|
if (!validStatuses.includes(beasiswa_status)) {
|
|
errors.push(`Baris ${i+2}: Status beasiswa tidak valid "${beasiswa_status}" untuk NIM ${nim}. Harus salah satu dari: ${validStatuses.join(', ')}`);
|
|
continue;
|
|
}
|
|
|
|
// Normalize jenis beasiswa
|
|
jenis_beasiswa = normalizeJenisBeasiswa(jenis_beasiswa);
|
|
|
|
// Validate jenis beasiswa
|
|
if (!validJenis.includes(jenis_beasiswa)) {
|
|
errors.push(`Baris ${i+2}: Jenis beasiswa tidak valid "${jenis_beasiswa}" untuk NIM ${nim}. Harus salah satu dari: ${validJenis.join(', ')}`);
|
|
continue;
|
|
}
|
|
|
|
// Add to valid data
|
|
validData.push({
|
|
nim,
|
|
nama_beasiswa,
|
|
sumber_beasiswa,
|
|
beasiswa_status,
|
|
jenis_beasiswa
|
|
});
|
|
|
|
} catch (error) {
|
|
errors.push(`Baris ${i+2}: Error memproses data - ${(error as Error).message}`);
|
|
}
|
|
}
|
|
|
|
return { validData, errors };
|
|
}
|
|
|
|
// Function to normalize beasiswa status values
|
|
function normalizeBeasiswaStatus(value: string): string {
|
|
const lowerValue = value.toLowerCase();
|
|
|
|
if (['aktif', 'active', 'a'].includes(lowerValue)) {
|
|
return 'Aktif';
|
|
}
|
|
|
|
if (['selesai', 'complete', 'completed', 's', 'finish', 'finished'].includes(lowerValue)) {
|
|
return 'Selesai';
|
|
}
|
|
|
|
if (['dibatalkan', 'cancel', 'cancelled', 'canceled', 'batal', 'd', 'c'].includes(lowerValue)) {
|
|
return 'Dibatalkan';
|
|
}
|
|
|
|
return value; // Return original if no match
|
|
}
|
|
|
|
// Function to normalize jenis beasiswa values
|
|
function normalizeJenisBeasiswa(value: string): string {
|
|
const lowerValue = value.toLowerCase();
|
|
|
|
if (['pemerintah', 'government', 'p', 'gov'].includes(lowerValue)) {
|
|
return 'Pemerintah';
|
|
}
|
|
|
|
if (['non-pemerintah', 'non pemerintah', 'nonpemerintah', 'swasta', 'private', 'np', 'non'].includes(lowerValue)) {
|
|
return 'Non-Pemerintah';
|
|
}
|
|
|
|
return value; // Return original if no match
|
|
}
|
|
|
|
// Function to insert data into database
|
|
async function insertDataToDatabase(data: any[]) {
|
|
let imported = 0;
|
|
let errorCount = 0;
|
|
const errorMessages: string[] = [];
|
|
|
|
console.log('=== DEBUG: Starting beasiswa 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 beasiswa data processing ===');
|
|
for (const item of data) {
|
|
try {
|
|
console.log(`\n--- Processing beasiswa 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 beasiswa check/insert`);
|
|
|
|
// Check if beasiswa already exists for this mahasiswa and nama_beasiswa
|
|
console.log(`Checking existing beasiswa for mahasiswa ID: ${nimValidation.id_mahasiswa}, nama_beasiswa: ${item.nama_beasiswa}`);
|
|
const { data: existingBeasiswa, error: beasiswaCheckError } = await supabase
|
|
.from('beasiswa_mahasiswa')
|
|
.select('id_beasiswa')
|
|
.eq('id_mahasiswa', nimValidation.id_mahasiswa)
|
|
.eq('nama_beasiswa', item.nama_beasiswa)
|
|
.single();
|
|
|
|
if (beasiswaCheckError && beasiswaCheckError.code !== 'PGRST116') {
|
|
console.log(`❌ Error checking existing beasiswa:`, beasiswaCheckError);
|
|
}
|
|
|
|
if (existingBeasiswa) {
|
|
console.log(`📝 Updating existing beasiswa (ID: ${existingBeasiswa.id_beasiswa})`);
|
|
// Update existing beasiswa
|
|
const { error: updateError } = await supabase
|
|
.from('beasiswa_mahasiswa')
|
|
.update({
|
|
sumber_beasiswa: item.sumber_beasiswa,
|
|
beasiswa_status: item.beasiswa_status,
|
|
jenis_beasiswa: item.jenis_beasiswa
|
|
})
|
|
.eq('id_beasiswa', existingBeasiswa.id_beasiswa);
|
|
|
|
if (updateError) {
|
|
errorCount++;
|
|
const errorMsg = `NIM ${item.nim} (${nimValidation.nama}): Gagal memperbarui beasiswa: ${updateError.message}`;
|
|
console.log(`❌ Update failed: ${errorMsg}`);
|
|
errorMessages.push(errorMsg);
|
|
continue;
|
|
} else {
|
|
console.log(`✅ Beasiswa updated successfully`);
|
|
}
|
|
} else {
|
|
console.log(`📝 Inserting new beasiswa for mahasiswa ID: ${nimValidation.id_mahasiswa}`);
|
|
// Insert new beasiswa
|
|
const { error: insertError } = await supabase
|
|
.from('beasiswa_mahasiswa')
|
|
.insert({
|
|
id_mahasiswa: nimValidation.id_mahasiswa,
|
|
nama_beasiswa: item.nama_beasiswa,
|
|
sumber_beasiswa: item.sumber_beasiswa,
|
|
beasiswa_status: item.beasiswa_status,
|
|
jenis_beasiswa: item.jenis_beasiswa
|
|
});
|
|
|
|
if (insertError) {
|
|
errorCount++;
|
|
const errorMsg = `NIM ${item.nim} (${nimValidation.nama}): Gagal menyimpan beasiswa: ${insertError.message}`;
|
|
console.log(`❌ Insert failed: ${errorMsg}`);
|
|
errorMessages.push(errorMsg);
|
|
continue;
|
|
} else {
|
|
console.log(`✅ Beasiswa 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 };
|
|
}
|