129 lines
3.8 KiB
TypeScript
129 lines
3.8 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server';
|
|
import { createClient } from '@/lib/auth/server';
|
|
import { supabaseAdmin } from '@/lib/supabase/server';
|
|
|
|
const BUCKET = 'screening-documents';
|
|
|
|
async function ensureBucket() {
|
|
const { data, error } = await supabaseAdmin.storage.getBucket(BUCKET);
|
|
if (!data) {
|
|
const { error: createError } = await supabaseAdmin.storage.createBucket(BUCKET, {
|
|
public: true,
|
|
fileSizeLimit: 50 * 1024 * 1024, // 50 MB
|
|
});
|
|
if (createError && !createError.message.includes('already exists')) {
|
|
throw createError;
|
|
}
|
|
} else if (error && !error.message.includes('not found')) {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function getPractitionerByUser(supabase: Awaited<ReturnType<typeof createClient>>, userId?: string) {
|
|
if (!userId) return null;
|
|
const { data } = await supabase
|
|
.from('practitioners')
|
|
.select('id, name_given, name_family')
|
|
.eq('user_id', userId)
|
|
.maybeSingle();
|
|
return data;
|
|
}
|
|
|
|
function formatDisplayName(practitioner: any, fallback: string) {
|
|
if (practitioner) {
|
|
const given = (practitioner.name_given || []).join(' ');
|
|
const family = practitioner.name_family || '';
|
|
return `${given} ${family}`.trim();
|
|
}
|
|
return fallback;
|
|
}
|
|
|
|
export async function POST(
|
|
request: NextRequest,
|
|
{ params }: { params: Promise<{ screeningId: string }> }
|
|
) {
|
|
try {
|
|
const { screeningId } = await params;
|
|
const supabase = await createClient();
|
|
|
|
const {
|
|
data: { user },
|
|
error: userError,
|
|
} = await supabase.auth.getUser();
|
|
|
|
if (userError || !user) {
|
|
return NextResponse.json({ error: 'Niet geautoriseerd' }, { status: 401 });
|
|
}
|
|
|
|
const formData = await request.formData();
|
|
const file = formData.get('file');
|
|
if (!(file instanceof File)) {
|
|
return NextResponse.json({ error: 'Bestand ontbreekt' }, { status: 400 });
|
|
}
|
|
|
|
const documentType = (formData.get('documentType') as string) || 'overig';
|
|
|
|
await ensureBucket();
|
|
|
|
const filePath = `${screeningId}/${Date.now()}-${file.name}`;
|
|
const arrayBuffer = await file.arrayBuffer();
|
|
const { error: uploadError } = await supabaseAdmin.storage
|
|
.from(BUCKET)
|
|
.upload(filePath, Buffer.from(arrayBuffer), {
|
|
contentType: file.type,
|
|
cacheControl: '3600',
|
|
upsert: false,
|
|
});
|
|
|
|
if (uploadError) {
|
|
console.error('Upload error:', uploadError);
|
|
return NextResponse.json(
|
|
{ error: 'Upload mislukt', details: uploadError.message },
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
|
|
const practitioner = await getPractitionerByUser(supabase, user.id);
|
|
const displayName = formatDisplayName(
|
|
practitioner,
|
|
(user.user_metadata?.full_name as string) || user.email || 'Onbekend'
|
|
);
|
|
|
|
const { data, error } = await supabase
|
|
.from('screening_documents')
|
|
.insert({
|
|
screening_id: screeningId,
|
|
file_name: file.name,
|
|
file_type: file.type,
|
|
file_size: file.size,
|
|
file_path: filePath,
|
|
document_type: documentType,
|
|
uploaded_by: practitioner?.id || null,
|
|
uploaded_by_name: displayName,
|
|
})
|
|
.select('*')
|
|
.single();
|
|
|
|
if (error) {
|
|
console.error('DB insert error:', error);
|
|
return NextResponse.json(
|
|
{ error: 'Opslaan mislukt', details: error.message },
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
|
|
const { data: publicUrlData } = supabaseAdmin.storage.from(BUCKET).getPublicUrl(filePath);
|
|
|
|
return NextResponse.json({
|
|
document: {
|
|
...data,
|
|
publicUrl: publicUrlData.publicUrl,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
console.error('Unexpected error in POST /documents:', error);
|
|
const message = error instanceof Error ? error.message : 'Unknown error';
|
|
return NextResponse.json({ error: message }, { status: 500 });
|
|
}
|
|
}
|