@omniradiology/omnirad 0.1.3

package/app/api/pacs/metadata/route.ts

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getOrthancHeaders } from "@/lib/pacs/server-utils";
+
+export async function GET(request: NextRequest) {
+    try {
+        const { headers, baseUrl } = await getOrthancHeaders();
+        const searchParams = request.nextUrl.searchParams;
+        const studyUid = searchParams.get('studyUid');
+
+        if (!studyUid) {
+            return NextResponse.json({ error: "Missing studyUid parameter" }, { status: 400 });
+        }
+
+        const orthancUrl = new URL(`${baseUrl}/studies/${studyUid}/metadata`);
+
+        const res = await fetch(orthancUrl.toString(), {
+            method: "GET",
+            headers,
+        });
+
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Orthanc returned ${res.status}: ${errText}`);
+        }
+
+        const data = await res.json();
+        return NextResponse.json(data);
+    } catch (e: any) {
+        console.error("PACS Metadata Proxy Error:", e);
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/pacs/qido/instances/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getOrthancHeaders } from "@/lib/pacs/server-utils";
+
+export async function GET(request: NextRequest) {
+    try {
+        const { headers, baseUrl } = await getOrthancHeaders();
+        const searchParams = request.nextUrl.searchParams;
+        const studyUid = searchParams.get('studyUid');
+        const seriesUid = searchParams.get('seriesUid');
+
+        if (!studyUid || !seriesUid) {
+            return NextResponse.json({ error: "Missing studyUid or seriesUid parameter" }, { status: 400 });
+        }
+
+        const orthancUrl = new URL(`${baseUrl}/studies/${studyUid}/series/${seriesUid}/instances`);
+        
+        searchParams.forEach((value, key) => {
+            if (key !== 'studyUid' && key !== 'seriesUid') {
+                orthancUrl.searchParams.append(key, value);
+            }
+        });
+
+        const res = await fetch(orthancUrl.toString(), {
+            method: "GET",
+            headers,
+        });
+
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Orthanc returned ${res.status}: ${errText}`);
+        }
+
+        const data = await res.json();
+        return NextResponse.json(data);
+    } catch (e: any) {
+        console.error("PACS Instances Proxy Error:", e);
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/pacs/qido/series/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getOrthancHeaders } from "@/lib/pacs/server-utils";
+
+export async function GET(request: NextRequest) {
+    try {
+        const { headers, baseUrl } = await getOrthancHeaders();
+        const searchParams = request.nextUrl.searchParams;
+        const studyUid = searchParams.get('studyUid');
+
+        if (!studyUid) {
+            return NextResponse.json({ error: "Missing studyUid parameter" }, { status: 400 });
+        }
+
+        const orthancUrl = new URL(`${baseUrl}/studies/${studyUid}/series`);
+        
+        searchParams.forEach((value, key) => {
+            if (key !== 'studyUid') {
+                orthancUrl.searchParams.append(key, value);
+            }
+        });
+
+        const res = await fetch(orthancUrl.toString(), {
+            method: "GET",
+            headers,
+        });
+
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Orthanc returned ${res.status}: ${errText}`);
+        }
+
+        const data = await res.json();
+        return NextResponse.json(data);
+    } catch (e: any) {
+        console.error("PACS Series Proxy Error:", e);
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/pacs/qido/studies/route.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getOrthancHeaders } from "@/lib/pacs/server-utils";
+
+export async function GET(request: NextRequest) {
+    try {
+        const { headers, baseUrl } = await getOrthancHeaders();
+        const searchParams = request.nextUrl.searchParams;
+
+        // E.g. /studies?PatientName=*John*&PatientID=123
+        const orthancUrl = new URL(baseUrl + "/studies");
+        
+        searchParams.forEach((value, key) => {
+            orthancUrl.searchParams.append(key, value);
+        });
+
+        // Add limit by default if not specified
+        if (!orthancUrl.searchParams.has('limit')) {
+            orthancUrl.searchParams.append('limit', '50');
+        }
+
+        const res = await fetch(orthancUrl.toString(), {
+            method: "GET",
+            headers,
+        });
+
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Orthanc returned ${res.status}: ${errText}`);
+        }
+
+        const data = await res.json();
+        return NextResponse.json(data);
+    } catch (e: any) {
+        console.error("PACS Studies Proxy Error:", e);
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/pacs/test/route.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+import { getOrthancHeaders } from "@/lib/pacs/server-utils";
+
+export async function GET() {
+    try {
+        const { headers, baseUrl } = await getOrthancHeaders();
+        // The most basic connectivity test is fetching the root system info or studies with limit 1
+        const rootUrl = new URL(baseUrl);
+        const testUrl = new URL("/studies?limit=1", baseUrl);
+        
+        console.log("Testing connection to:", testUrl.toString());
+
+        const res = await fetch(testUrl.toString(), {
+            method: "GET",
+            headers,
+        });
+
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Orthanc returned ${res.status}: ${errText}`);
+        }
+
+        const data = await res.json();
+        
+        return NextResponse.json({ success: true, count: data?.length || 0 });
+    } catch (e: any) {
+        console.error("PACS Test Route Error:", e);
+        return NextResponse.json({ success: false, error: e.message }, { status: 500 });
+    }
+}

package/app/api/pacs/wado/render/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getOrthancHeaders } from "@/lib/pacs/server-utils";
+
+export async function GET(request: NextRequest) {
+    try {
+        const { headers, baseUrl } = await getOrthancHeaders();
+        const searchParams = request.nextUrl.searchParams;
+        const studyUid = searchParams.get('studyUid');
+        const seriesUid = searchParams.get('seriesUid');
+        const instanceUid = searchParams.get('instanceUid');
+        const frame = searchParams.get('frame');
+
+        if (!studyUid || !seriesUid || !instanceUid) {
+            return new NextResponse("Missing studyUid, seriesUid, or instanceUid parameter", { status: 400 });
+        }
+
+        // If a frame number is specified, fetch that specific frame from a multi-frame instance
+        let renderPath = `${baseUrl}/studies/${studyUid}/series/${seriesUid}/instances/${instanceUid}`;
+        if (frame) {
+            renderPath += `/frames/${frame}/rendered`;
+        } else {
+            renderPath += `/rendered`;
+        }
+        const orthancUrl = new URL(renderPath);
+
+        // Ask for jpeg explicitly if Orthanc supports it via accept headers
+        const fetchHeaders = { ...headers, "Accept": "image/jpeg" };
+
+        const res = await fetch(orthancUrl.toString(), {
+            method: "GET",
+            headers: fetchHeaders,
+        });
+
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Orthanc returned ${res.status}: ${errText}`);
+        }
+
+        // Return the binary body directly
+        const contentType = res.headers.get("content-type") || "image/jpeg";
+        return new NextResponse(res.body, {
+            headers: {
+                "Content-Type": contentType,
+                "Cache-Control": "public, max-age=86400",
+            },
+        });
+    } catch (e: any) {
+        console.error("PACS Render Proxy Error:", e);
+        return new NextResponse(e.message, { status: 500 });
+    }
+}

package/app/api/patients/[id]/reports/route.ts

@@ -0,0 +1,18 @@
+import { db } from "@/db";
+import { reports } from "@/db/schema";
+import { eq, desc } from "drizzle-orm";
+import { NextResponse } from "next/server";
+
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+    try {
+        const { id } = await params;
+        const data = await db.select()
+            .from(reports)
+            .where(eq(reports.patientId, id))
+            .orderBy(desc(reports.createdAt));
+        
+        return NextResponse.json(data);
+    } catch (e: any) {
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/patients/[id]/route.ts

@@ -0,0 +1,43 @@
+import { db } from "@/db";
+import { patients, reports } from "@/db/schema";
+import { eq, desc } from "drizzle-orm";
+import { NextResponse } from "next/server";
+
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+    try {
+        const { id } = await params;
+        const result = await db.select().from(patients).where(eq(patients.id, id)).limit(1);
+        if (result.length === 0) {
+            return NextResponse.json({ error: "Patient not found" }, { status: 404 });
+        }
+        return NextResponse.json(result[0]);
+    } catch (e: any) {
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+    try {
+        const { id } = await params;
+        const body = await req.json();
+        const updates = {
+            ...body,
+            updatedAt: new Date().toISOString()
+        };
+        await db.update(patients).set(updates).where(eq(patients.id, id));
+        return NextResponse.json({ success: true });
+    } catch (e: any) {
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}
+
+export async function DELETE(req: Request, { params }: { params: Promise<{ id: string }> }) {
+    try {
+        const { id } = await params;
+        // The cascading delete is on the DB schema, so deleting the patient should delete reports.
+        await db.delete(patients).where(eq(patients.id, id));
+        return NextResponse.json({ success: true });
+    } catch (e: any) {
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/patients/merge/route.ts

@@ -0,0 +1,57 @@
+import { db } from "@/db";
+import { patients, reports } from "@/db/schema";
+import { isNull, eq } from "drizzle-orm";
+import { NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+
+export async function POST(req: Request) {
+    try {
+        const body = await req.json();
+        
+        if (body.action === "auto-migrate") {
+            const nullReports = await db.select().from(reports).where(isNull(reports.patientId));
+            let migratedCount = 0;
+            
+            for (const r of nullReports) {
+                if (!r.reportData) continue;
+                try {
+                    const parsed = JSON.parse(r.reportData);
+                    const pName = r.patientName || parsed.patient?.name;
+                    if (!pName) continue;
+                    
+                    // Does this patient exist?
+                    const existing = await db.select().from(patients).where(eq(patients.patientName, pName)).limit(1);
+                    
+                    let pId = "";
+                    if (existing.length > 0) {
+                        pId = existing[0].id;
+                    } else {
+                        pId = randomUUID();
+                        await db.insert(patients).values({
+                            id: pId,
+                            patientName: pName,
+                            patientIdNumber: parsed.patient?.patient_id || null,
+                            gender: parsed.patient?.gender || null,
+                            dob: parsed.patient?.age ? null : null, // Not inferring DOB from age directly
+                            createdAt: new Date().toISOString(),
+                            updatedAt: new Date().toISOString()
+                        });
+                    }
+                    
+                    // Link report
+                    await db.update(reports).set({ patientId: pId }).where(eq(reports.id, r.id));
+                    migratedCount++;
+                } catch(err) {
+                    console.error("[OmniRad] Migration error on report", r.id, err);
+                }
+            }
+            
+            return NextResponse.json({ success: true, migrated: migratedCount });
+        }
+        
+        return NextResponse.json({ error: "Invalid action" }, { status: 400 });
+    } catch (e: any) {
+        console.error(e);
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/patients/route.ts

@@ -0,0 +1,67 @@
+import { db } from "@/db";
+import { patients, reports } from "@/db/schema";
+import { NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { desc, like, or } from "drizzle-orm";
+
+export async function GET(req: Request) {
+    try {
+        const url = new URL(req.url);
+        const search = url.searchParams.get("search");
+
+        let query = db.select().from(patients);
+
+        if (search) {
+            query = query.where(
+                or(
+                    like(patients.patientName, `%${search}%`),
+                    like(patients.patientIdNumber, `%${search}%`)
+                )
+            ) as any;
+        }
+
+        const data = await query.orderBy(desc(patients.createdAt));
+
+        // Get report counts for these patients
+        const counts = db.select({ patientId: reports.patientId }).from(reports).all();
+        const countsMap = counts.reduce((acc: any, curr) => {
+            if (curr.patientId) {
+                acc[curr.patientId] = (acc[curr.patientId] || 0) + 1;
+            }
+            return acc;
+        }, {});
+
+        const enrichedData = data.map((p) => ({
+            ...p,
+            reportCount: countsMap[p.id] || 0
+        }));
+
+        return NextResponse.json(enrichedData);
+    } catch (e: any) {
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}
+
+export async function POST(req: Request) {
+    try {
+        const body = await req.json();
+        const newPatient = {
+            id: randomUUID(),
+            patientName: body.patientName,
+            patientIdNumber: body.patientIdNumber || null,
+            dob: body.dob || null,
+            age: body.age || null,
+            gender: body.gender || null,
+            contactInfo: body.contactInfo || null,
+            notes: body.notes || null,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+
+        await db.insert(patients).values(newPatient);
+
+        return NextResponse.json(newPatient);
+    } catch (e: any) {
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/patients/search/route.ts

@@ -0,0 +1,25 @@
+import { db } from "@/db";
+import { patients } from "@/db/schema";
+import { desc, like, or } from "drizzle-orm";
+import { NextResponse } from "next/server";
+
+export async function GET(req: Request) {
+    try {
+        const url = new URL(req.url);
+        const q = url.searchParams.get("q");
+
+        if (!q || q.length < 2) {
+            return NextResponse.json([]);
+        }
+
+        const data = await db.select().from(patients).where(
+            or(
+                like(patients.patientName, `%${q}%`),
+                like(patients.patientIdNumber, `%${q}%`)
+            )
+        ).orderBy(desc(patients.createdAt)).limit(10);
+        return NextResponse.json(data);
+    } catch (e: any) {
+        return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+}

package/app/api/reports/[id]/route.ts

@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { reports } from "@/db/schema";
+import { eq } from "drizzle-orm";
+
+// GET /api/reports/[id] — Get a single report
+export async function GET(
+    _request: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { id } = await params;
+    try {
+        const row = db.select().from(reports).where(eq(reports.id, id)).get();
+        if (!row) {
+            return NextResponse.json({ error: "Report not found" }, { status: 404 });
+        }
+        const reportData = JSON.parse(row.reportData);
+        if (row.imageData && !reportData.image_data) {
+            reportData.image_data = row.imageData;
+        }
+
+        return NextResponse.json({
+            id: row.id,
+            patient_name: row.patientName,
+            modality: row.modality,
+            urgency: row.urgency,
+            report_status: row.reportStatus,
+            report_data: reportData,
+            created_at: row.createdAt,
+        });
+    } catch (error) {
+        console.error("[API] Error fetching report:", error);
+        return NextResponse.json({ error: "Failed to fetch report" }, { status: 500 });
+    }
+}
+
+// PUT /api/reports/[id] — Update report data
+export async function PUT(
+    request: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { id } = await params;
+    try {
+        const body = await request.json();
+        const { updates } = body;
+
+        // Get current report
+        const row = db.select().from(reports).where(eq(reports.id, id)).get();
+        if (!row) {
+            return NextResponse.json({ error: "Report not found" }, { status: 404 });
+        }
+
+        const currentData = JSON.parse(row.reportData);
+        const updatedData = { ...currentData, ...updates };
+
+        db.update(reports)
+            .set({
+                reportData: JSON.stringify(updatedData),
+                urgency: updatedData.urgency || row.urgency,
+            })
+            .where(eq(reports.id, id))
+            .run();
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error("[API] Error updating report:", error);
+        return NextResponse.json({ error: "Failed to update report" }, { status: 500 });
+    }
+}
+
+// DELETE /api/reports/[id] — Delete a report
+export async function DELETE(
+    _request: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { id } = await params;
+    try {
+        db.delete(reports).where(eq(reports.id, id)).run();
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error("[API] Error deleting report:", error);
+        return NextResponse.json({ error: "Failed to delete report" }, { status: 500 });
+    }
+}

package/app/api/reports/[id]/status/route.ts

@@ -0,0 +1,87 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { reports } from "@/db/schema";
+import { eq } from "drizzle-orm";
+
+// PATCH /api/reports/[id]/status — Update report status (approve/reject/unreject)
+export async function PATCH(
+    request: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { id } = await params;
+    try {
+        const body = await request.json();
+        const { status, signature, rejectionReason, notes, userName, userRole } = body;
+
+        // Get current report
+        const row = db.select().from(reports).where(eq(reports.id, id)).get();
+        if (!row) {
+            return NextResponse.json({ error: "Report not found" }, { status: 404 });
+        }
+
+        const updatedData = JSON.parse(row.reportData);
+
+        // Update status in report_data
+        updatedData.report_footer.report_status = status;
+
+        // Collaboration: logs & comments
+        if (!updatedData.collaboration) {
+            updatedData.collaboration = { comments: [], logs: [] };
+        }
+        const timestamp = new Date().toISOString();
+        const user = userName || "System";
+
+        updatedData.collaboration.logs.push({
+            id: `log_${Date.now()}`,
+            action: `Status Changed to ${status}`,
+            user,
+            timestamp,
+            details: status === "Rejected" ? `Reason: ${rejectionReason}` :
+                status === "Approved" ? "Report Approved" : "Status reset",
+        });
+
+        if (notes || rejectionReason) {
+            updatedData.collaboration.comments.push({
+                id: `comment_${Date.now()}`,
+                author: user,
+                role: userRole || "System",
+                text: notes || rejectionReason || "",
+                timestamp,
+            });
+        }
+
+        // Handle approval
+        if (status === "Approved") {
+            updatedData.report_footer.approved_at = timestamp;
+            if (signature) updatedData.report_footer.signature = signature;
+            updatedData.report_footer.approved_by = user;
+        }
+
+        // Handle rejection
+        if (status === "Rejected" && rejectionReason) {
+            updatedData.report_footer.rejection_reason = rejectionReason;
+        }
+
+        // Handle unreject (clear rejection reason)
+        if (status === "Pending") {
+            updatedData.report_footer.rejection_reason = undefined;
+        }
+
+        // Update SQLite
+        db.update(reports)
+            .set({
+                reportData: JSON.stringify(updatedData),
+                reportStatus: status,
+            })
+            .where(eq(reports.id, id))
+            .run();
+
+        return NextResponse.json({
+            success: true,
+            report_data: updatedData,
+        });
+    } catch (error) {
+        console.error("[API] Error updating report status:", error);
+        return NextResponse.json({ error: "Failed to update status" }, { status: 500 });
+    }
+}

package/app/api/reports/clear/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { db } from "@/db";
+import { reports, patients } from "@/db/schema";
+
+// DELETE /api/reports/clear — Delete all reports and patients
+export async function DELETE() {
+    try {
+        db.delete(reports).run();
+        db.delete(patients).run();
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error("[API] Error clearing reports:", error);
+        return NextResponse.json({ error: "Failed to clear reports" }, { status: 500 });
+    }
+}
+