Revert "cleanup v2"

This reverts commit 8b82578809.

app/api/servers/add/route.ts

@@ -0,0 +1,48 @@
+import { NextResponse, NextRequest } from "next/server";
+import { prisma } from "@/lib/prisma";
+
+interface AddRequest {
+    host: boolean;
+    hostServer: number;
+    name: string;
+    icon: string;
+    os: string;
+    ip: string;
+    url: string;
+    cpu: string;
+    gpu: string;
+    ram: string;
+    disk: string;
+    monitoring: boolean;
+    monitoringURL: string;
+
+}
+
+export async function POST(request: NextRequest) {
+    try {
+        const body: AddRequest = await request.json();
+        const { host, hostServer, name, icon, os, ip, url, cpu, gpu, ram, disk, monitoring, monitoringURL } = body;  
+        
+        const server = await prisma.server.create({
+            data: {
+                host,
+                hostServer,
+                name,
+                icon,
+                os,
+                ip,
+                url,
+                cpu,
+                gpu,
+                ram,
+                disk,
+                monitoring,
+                monitoringURL
+            }
+        });
+
+        return NextResponse.json({ message: "Success", server });
+    } catch (error: any) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

app/api/servers/delete/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse, NextRequest } from "next/server";
+import { prisma } from "@/lib/prisma";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const id = Number(body.id);
+
+    if (!id) {
+      return NextResponse.json({ error: "Missing ID" }, { status: 400 });
+    }
+    
+    // Check if there are any applications associated with the server
+    const applications = await prisma.application.findMany({
+      where: { serverId: id }
+    });
+    if (applications.length > 0) {
+      return NextResponse.json({ error: "Cannot delete server with associated applications" }, { status: 400 });
+    }
+
+    // Delete all server history records for this server
+    await prisma.server_history.deleteMany({
+      where: { serverId: id }
+    });
+
+    // Delete the server
+    await prisma.server.delete({
+      where: { id: id }
+    });
+
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

app/api/servers/edit/route.ts

@@ -0,0 +1,61 @@
+import { NextResponse, NextRequest } from "next/server";
+import { prisma } from "@/lib/prisma";
+
+interface EditRequest {
+    host: boolean;
+    hostServer: number;
+    id: number;
+    name: string;
+    icon: string;
+    os: string;
+    ip: string;
+    url: string;
+    cpu: string;
+    gpu: string;
+    ram: string;
+    disk: string;
+    monitoring: boolean;
+    monitoringURL: string;
+}
+
+export async function PUT(request: NextRequest) {
+    try {
+        const body: EditRequest = await request.json();
+        const { host, hostServer, id, name, icon, os, ip, url, cpu, gpu, ram, disk, monitoring, monitoringURL } = body;
+
+        const existingServer = await prisma.server.findUnique({ where: { id } });
+        if (!existingServer) {
+            return NextResponse.json({ error: "Server not found" }, { status: 404 });
+        }
+
+        let newHostServer = hostServer;
+        if (hostServer === null) {
+            newHostServer = 0;
+        } else {
+            newHostServer = hostServer;
+        }
+
+        const updatedServer = await prisma.server.update({
+            where: { id },
+            data: { 
+                host,
+                hostServer: newHostServer,
+                name, 
+                icon,
+                os, 
+                ip, 
+                url,
+                cpu,
+                gpu,
+                ram,
+                disk,
+                monitoring,
+                monitoringURL
+            }
+        });
+
+        return NextResponse.json({ message: "Server updated", server: updatedServer });
+    } catch (error: any) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

app/api/servers/get/route.ts

@@ -0,0 +1,270 @@
+import { NextResponse, NextRequest } from "next/server";
+import { prisma } from "@/lib/prisma";
+import { Prisma } from "@prisma/client";
+
+interface GetRequest {
+    page?: number;
+    ITEMS_PER_PAGE?: number;
+    timeRange?: '1h' | '1d' | '7d' | '30d';
+    serverId?: number;
+}
+
+const getTimeRange = (timeRange: '1h' | '1d' | '7d' | '30d' = '1h') => {
+    const now = new Date();
+    switch (timeRange) {
+        case '1d':
+            return {
+                start: new Date(now.getTime() - 24 * 60 * 60 * 1000),
+                end: now,
+                intervalMinutes: 15 // 15 minute intervals
+            };
+        case '7d':
+            return {
+                start: new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000),
+                end: now,
+                intervalMinutes: 60 // 1 hour intervals
+            };
+        case '30d':
+            return {
+                start: new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000),
+                end: now,
+                intervalMinutes: 240 // 4 hour intervals
+            };
+        case '1h':
+        default:
+            return {
+                start: new Date(now.getTime() - 60 * 60 * 1000),
+                end: now,
+                intervalMinutes: 1 // 1 minute intervals
+            };
+    }
+};
+
+const getIntervals = (timeRange: '1h' | '1d' | '7d' | '30d' = '1h') => {
+    const { start, end, intervalMinutes } = getTimeRange(timeRange);
+    
+    let intervalCount: number;
+    switch (timeRange) {
+        case '1d':
+            intervalCount = 96; // 24 hours * 4 (15-minute intervals)
+            break;
+        case '7d':
+            intervalCount = 168; // 7 days * 24 hours
+            break;
+        case '30d':
+            intervalCount = 180; // 30 days * 6 (4-hour intervals)
+            break;
+        case '1h':
+        default:
+            intervalCount = 60;
+            break;
+    }
+
+    // Calculate the total time span in minutes
+    const totalMinutes = Math.floor((end.getTime() - start.getTime()) / (1000 * 60));
+    
+    // Create equally spaced intervals
+    return Array.from({ length: intervalCount }, (_, i) => {
+        const minutesFromEnd = Math.floor(i * (totalMinutes / (intervalCount - 1)));
+        const d = new Date(end.getTime() - minutesFromEnd * 60 * 1000);
+        return d;
+    }).reverse(); // Return in chronological order
+};
+
+const parseUsageValue = (value: string | null): number => {
+    if (!value) return 0;
+    return Math.round(parseFloat(value.replace('%', '')) * 100) / 100;
+};
+
+export async function POST(request: NextRequest) {
+    try {
+        const body: GetRequest = await request.json();
+        const page = Math.max(1, body.page || 1);
+        const ITEMS_PER_PAGE = body.ITEMS_PER_PAGE || 4;
+        const timeRange = body.timeRange || '1h';
+        const serverId = body.serverId;
+
+        // If serverId is provided, only fetch that specific server
+        const hostsQuery = serverId 
+            ? { id: serverId }
+            : { hostServer: 0 };
+        
+        let hosts;
+        if (!serverId) {
+            hosts = await prisma.server.findMany({
+                where: hostsQuery,
+                orderBy: { name: 'asc' as Prisma.SortOrder },
+                skip: (page - 1) * ITEMS_PER_PAGE,
+                take: ITEMS_PER_PAGE,
+            });
+        } else {
+            hosts = await prisma.server.findMany({
+                where: hostsQuery,
+                orderBy: { name: 'asc' as Prisma.SortOrder },
+            });
+        }
+
+        const { start } = getTimeRange(timeRange);
+        const intervals = getIntervals(timeRange);
+
+        const hostsWithVms = await Promise.all(
+            hosts.map(async (host) => {
+                const vms = await prisma.server.findMany({
+                    where: { hostServer: host.id },
+                    orderBy: { name: 'asc' }
+                });
+                
+                // Get server history for the host
+                const serverHistory = await prisma.server_history.findMany({
+                    where: {
+                        serverId: host.id,
+                        createdAt: {
+                            gte: start
+                        }
+                    },
+                    orderBy: {
+                        createdAt: 'asc'
+                    }
+                });
+
+                // Process history data into intervals
+                const historyMap = new Map<string, { 
+                    cpu: number[],
+                    ram: number[],
+                    disk: number[],
+                    gpu: number[],
+                    temp: number[],
+                    online: boolean[]
+                }>();
+
+                // Initialize intervals
+                intervals.forEach(date => {
+                    const key = date.toISOString();
+                    historyMap.set(key, {
+                        cpu: [],
+                        ram: [],
+                        disk: [],
+                        gpu: [],
+                        temp: [],
+                        online: []
+                    });
+                });
+
+                // Group data by interval
+                serverHistory.forEach(record => {
+                    const recordDate = new Date(record.createdAt);
+                    let nearestInterval: Date = intervals[0];
+                    let minDiff = Infinity;
+
+                    // Find the nearest interval for this record
+                    intervals.forEach(intervalDate => {
+                        const diff = Math.abs(recordDate.getTime() - intervalDate.getTime());
+                        if (diff < minDiff) {
+                            minDiff = diff;
+                            nearestInterval = intervalDate;
+                        }
+                    });
+
+                    const key = nearestInterval.toISOString();
+                    const interval = historyMap.get(key);
+                    if (interval) {
+                        interval.cpu.push(parseUsageValue(record.cpuUsage));
+                        interval.ram.push(parseUsageValue(record.ramUsage));
+                        interval.disk.push(parseUsageValue(record.diskUsage));
+                        interval.gpu.push(parseUsageValue(record.gpuUsage));
+                        interval.temp.push(parseUsageValue(record.temp));
+                        interval.online.push(record.online);
+                    }
+                });
+
+                // Calculate averages for each interval
+                const historyData = intervals.map(date => {
+                    const key = date.toISOString();
+                    const data = historyMap.get(key) || {
+                        cpu: [],
+                        ram: [],
+                        disk: [],
+                        gpu: [],
+                        temp: [],
+                        online: []
+                    };
+
+                    const average = (arr: number[]) => 
+                        arr.length ? Math.round((arr.reduce((a, b) => a + b, 0) / arr.length) * 100) / 100 : null;
+
+                    return {
+                        timestamp: key,
+                        cpu: average(data.cpu),
+                        ram: average(data.ram),
+                        disk: average(data.disk),
+                        gpu: average(data.gpu),
+                        temp: average(data.temp),
+                        online: data.online.length ? 
+                            data.online.filter(Boolean).length / data.online.length >= 0.5 
+                            : null
+                    };
+                });
+                
+                // Add isVM flag to VMs
+                const vmsWithFlag = vms.map(vm => ({
+                    ...vm,
+                    isVM: true,
+                    hostedVMs: [] // Initialize empty hostedVMs array for VMs
+                }));
+                
+                return {
+                    ...host,
+                    isVM: false,
+                    hostedVMs: vmsWithFlag,
+                    history: {
+                        labels: intervals.map(d => d.toISOString()),
+                        datasets: {
+                            cpu: intervals.map(d => {
+                                const data = historyMap.get(d.toISOString())?.cpu || [];
+                                return data.length ? Math.round((data.reduce((a, b) => a + b) / data.length) * 100) / 100 : null;
+                            }),
+                            ram: intervals.map(d => {
+                                const data = historyMap.get(d.toISOString())?.ram || [];
+                                return data.length ? Math.round((data.reduce((a, b) => a + b) / data.length) * 100) / 100 : null;
+                            }),
+                            disk: intervals.map(d => {
+                                const data = historyMap.get(d.toISOString())?.disk || [];
+                                return data.length ? Math.round((data.reduce((a, b) => a + b) / data.length) * 100) / 100 : null;
+                            }),
+                            gpu: intervals.map(d => {
+                                const data = historyMap.get(d.toISOString())?.gpu || [];
+                                return data.length ? Math.round((data.reduce((a, b) => a + b) / data.length) * 100) / 100 : null;
+                            }),
+                            temp: intervals.map(d => {
+                                const data = historyMap.get(d.toISOString())?.temp || [];
+                                return data.length ? Math.round((data.reduce((a, b) => a + b) / data.length) * 100) / 100 : null;
+                            }),
+                            online: intervals.map(d => {
+                                const data = historyMap.get(d.toISOString())?.online || [];
+                                return data.length ? data.filter(Boolean).length / data.length >= 0.5 : null;
+                            })
+                        }
+                    }
+                };
+            })
+        );
+
+        // Only calculate maxPage when not requesting a specific server
+        let maxPage = 1;
+        let totalHosts = 0;
+        if (!serverId) {
+            totalHosts = await prisma.server.count({
+                where: { OR: [{ hostServer: 0 }, { hostServer: null }] }
+            });
+            maxPage = Math.ceil(totalHosts / ITEMS_PER_PAGE);
+        }
+
+        return NextResponse.json({ 
+            servers: hostsWithVms,
+            maxPage,
+            totalItems: totalHosts
+        });
+    } catch (error: any) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

app/api/servers/hosts/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse, NextRequest } from "next/server";
+import { prisma } from "@/lib/prisma";
+
+export async function GET(request: NextRequest) {
+    try {
+        const servers = await prisma.server.findMany({
+            where: { host: true },
+        });
+        
+        // Add required properties to ensure consistency
+        const serversWithProps = servers.map(server => ({
+            ...server,
+            isVM: false,
+            hostedVMs: [] // Initialize empty hostedVMs array
+        }));
+        
+        return NextResponse.json({ servers: serversWithProps });
+    } catch (error: any) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}

app/api/servers/monitoring/route.ts

@@ -0,0 +1,44 @@
+import { NextResponse } from "next/server"
+import { prisma } from "@/lib/prisma";
+
+
+export async function GET() {
+  try {
+    const servers = await prisma.server.findMany({
+      select: {
+        id: true,
+        online: true,
+        cpuUsage: true,
+        ramUsage: true,
+        diskUsage: true,
+        gpuUsage: true,
+        temp: true,
+        uptime: true
+      }
+    });
+
+    const monitoringData = servers.map((server: {
+      id: number;
+      online: boolean;
+      cpuUsage: string | null;
+      ramUsage: string | null;
+      diskUsage: string | null;
+      gpuUsage: string | null;
+      temp: string | null;
+      uptime: string | null;
+    }) => ({
+      id: server.id,
+      online: server.online,
+      cpuUsage: server.cpuUsage ? parseFloat(server.cpuUsage) : 0,
+      ramUsage: server.ramUsage ? parseFloat(server.ramUsage) : 0,
+      diskUsage: server.diskUsage ? parseFloat(server.diskUsage) : 0,
+      gpuUsage: server.gpuUsage ? parseFloat(server.gpuUsage) : 0,
+      temp: server.temp ? parseFloat(server.temp) : 0,
+      uptime: server.uptime || ""
+    }));
+
+    return NextResponse.json(monitoringData)
+  } catch (error) {
+    return new NextResponse("Internal Error", { status: 500 })
+  }
+} 

app/api/servers/search/route.ts

@@ -0,0 +1,68 @@
+import { NextResponse, NextRequest } from "next/server";
+import { prisma } from "@/lib/prisma";
+import Fuse from "fuse.js";
+
+interface SearchRequest {
+    searchterm: string;
+}
+
+export async function POST(request: NextRequest) {
+    try {
+        const body: SearchRequest = await request.json();
+        const { searchterm } = body;  
+        
+        // Fetch all servers
+        const servers = await prisma.server.findMany({});
+        
+        // Create a map of host servers with their hosted VMs
+        const serverMap = new Map();
+        servers.forEach(server => {
+            if (server.host) {
+                serverMap.set(server.id, {
+                    ...server,
+                    isVM: false,
+                    hostedVMs: []
+                });
+            }
+        });
+        
+        // Add VMs to their host servers and mark them as VMs
+        const serversWithType = servers.map(server => {
+            // If not a host and has a hostServer, it's a VM
+            if (!server.host && server.hostServer) {
+                const hostServer = serverMap.get(server.hostServer);
+                if (hostServer) {
+                    hostServer.hostedVMs.push({
+                        ...server,
+                        isVM: true
+                    });
+                }
+                return {
+                    ...server,
+                    isVM: true
+                };
+            }
+            return {
+                ...server,
+                isVM: false,
+                hostedVMs: serverMap.get(server.id)?.hostedVMs || []
+            };
+        });
+
+        const fuseOptions = {
+            keys: ['name', 'description', 'cpu', 'gpu', 'ram', 'disk', 'os'],
+            threshold: 0.3,
+            includeScore: true,
+        };
+
+        const fuse = new Fuse(serversWithType, fuseOptions);
+        
+        const searchResults = fuse.search(searchterm);
+
+        const results = searchResults.map(({ item }) => item);
+
+        return NextResponse.json({ results });
+    } catch (error: any) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+}