core/Projektarbeit-MYP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bereinige und vereinfache Installations-Skripte

Browse Source 
- Entferne alle überflüssigen Installations- und Konfigurationsskripte
- Erstelle zwei vereinfachte Docker-Installationsskripte:
  - install-frontend.sh für Frontend-Installation
  - install-backend.sh für Backend-Installation
- Verbessere Frontend Dockerfile mit besserer Unterstützung für native Dependencies
- Aktualisiere Backend Dockerfile für automatische DB-Initialisierung
- Korrigiere TypeScript-Fehler in personalized-cards.tsx
- Erstelle env.ts für Umgebungsvariablen-Verwaltung
- Füge ausführliche Installationsanleitung in INSTALL.md hinzu
- Konfiguriere Docker-Compose für Host-Netzwerkmodus
- Erweitere Dockerfiles mit Healthchecks für bessere Zuverlässigkeit

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Till Tomczak
2025-03-31 14:22:07 +02:00
parent fc62086a50
commit f1541478ad
198 changed files with 1903 additions and 17934 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
packages/reservation-platform/src/utils/analytics/.gitkeep Normal file
View File

54
packages/reservation-platform/src/utils/analytics/error-rate.ts
View File

@@ -1,54 +0,0 @@
import type { printJobs } from "@/server/db/schema";
import type { InferResultType } from "@/utils/drizzle";
import type { InferSelectModel } from "drizzle-orm";
export interface PrinterErrorRate {
printerId: string;
name: string;
errorRate: number; // Error rate as a percentage (0-100)
}
/**
* Calculates the error rate for print jobs aggregated by printer as a percentage.
*
* @param pJobs - Array of print job objects.
* @returns An array of PrinterErrorRate objects, each containing the printer ID and its error rate.
*/
export function calculatePrinterErrorRate(
pJobs: InferResultType<"printJobs", { printer: true }>[],
): PrinterErrorRate[] {
if (pJobs.length === 0) {
return []; // No jobs, no data.
}
const printers = pJobs.map((job) => job.printer);
// Group jobs by printer ID
const jobsByPrinter: Record<string, InferSelectModel<typeof printJobs>[]> = pJobs.reduce(
(acc, job) => {
if (!acc[job.printerId]) {
acc[job.printerId] = [];
}
acc[job.printerId].push(job);
return acc;
},
{} as Record<string, InferSelectModel<typeof printJobs>[]>,
);
// Calculate the error rate for each printer
const printerErrorRates: PrinterErrorRate[] = Object.entries(jobsByPrinter).map(([printerId, jobs]) => {
const totalJobs = jobs.length;
const abortedJobsCount = jobs.filter((job) => job.aborted).length;
const errorRate = (abortedJobsCount / totalJobs) * 100;
const printer = printers.find((printer) => printer.id === printerId);
const printerName = printer ? printer.name : "Unbekannter Drucker";
return {
printerId,
name: printerName,
errorRate: Number.parseFloat(errorRate.toFixed(2)), // Rounded to two decimal places
};
});
return printerErrorRates;
}

39
packages/reservation-platform/src/utils/analytics/errors.ts
View File

@@ -1,39 +0,0 @@
import type { InferResultType } from "@/utils/drizzle";
export interface AbortReasonCount {
abortReason: string;
count: number;
}
/**
* Calculates the count of each unique abort reason for print jobs.
*
* @param pJobs - Array of print job objects.
* @returns An array of AbortReasonCount objects, each containing the abort reason and its count.
*/
export function calculateAbortReasonsCount(pJobs: InferResultType<"printJobs">[]): AbortReasonCount[] {
if (pJobs.length === 0) {
return []; // No jobs, no data.
}
// Filter aborted jobs and count each abort reason
const abortReasonsCount = pJobs
.filter((job) => job.aborted && job.abortReason) // Consider only aborted jobs with a reason
.reduce(
(acc, job) => {
const reason = job.abortReason || "Unbekannter Grund";
if (!acc[reason]) {
acc[reason] = 0;
}
acc[reason]++;
return acc;
},
{} as Record<string, number>,
);
// Convert the result to an array of AbortReasonCount objects
return Object.entries(abortReasonsCount).map(([abortReason, count]) => ({
abortReason,
count,
}));
}

97
packages/reservation-platform/src/utils/analytics/forecast.ts
View File

@@ -1,97 +0,0 @@
import type { InferResultType } from "@/utils/drizzle";
type UsagePerDay = {
day: number; // 0 (Sunday) to 6 (Saturday)
usageMinutes: number;
};
function aggregateUsageByDay(jobs: InferResultType<"printJobs">[]): {
usageData: UsagePerDay[];
earliestDate: Date;
latestDate: Date;
} {
const usagePerDayMap = new Map<number, number>();
let earliestDate: Date | null = null;
let latestDate: Date | null = null;
for (const job of jobs) {
let remainingDuration = job.durationInMinutes;
const currentStart = new Date(job.startAt);
// Update earliest and latest dates
if (!earliestDate || currentStart < earliestDate) {
earliestDate = new Date(currentStart);
}
const jobEnd = new Date(currentStart);
jobEnd.setMinutes(jobEnd.getMinutes() + job.durationInMinutes);
if (!latestDate || jobEnd > latestDate) {
latestDate = new Date(jobEnd);
}
while (remainingDuration > 0) {
const day = currentStart.getDay();
// Calculate minutes remaining in the current day
const minutesRemainingInDay = (24 - currentStart.getHours()) * 60 - currentStart.getMinutes();
const minutesToAdd = Math.min(remainingDuration, minutesRemainingInDay);
// Update the usage for the current day
const usageMinutes = usagePerDayMap.get(day) || 0;
usagePerDayMap.set(day, usageMinutes + minutesToAdd);
// Update remaining duration and move to the next day
remainingDuration -= minutesToAdd;
currentStart.setDate(currentStart.getDate() + 1);
currentStart.setHours(0, 0, 0, 0); // Start at the beginning of the next day
}
}
const usageData: UsagePerDay[] = Array.from({ length: 7 }, (_, day) => ({
day,
usageMinutes: usagePerDayMap.get(day) || 0,
}));
if (earliestDate === null) {
earliestDate = new Date();
}
if (latestDate === null) {
latestDate = new Date();
}
return { usageData, earliestDate: earliestDate, latestDate: latestDate };
}
function countWeekdays(startDate: Date, endDate: Date): number[] {
const countPerDay = Array(7).fill(0);
const currentDate = new Date(startDate);
currentDate.setHours(0, 0, 0, 0); // Ensure starting at midnight
endDate.setHours(0, 0, 0, 0); // Ensure ending at midnight
while (currentDate <= endDate) {
const day = currentDate.getDay();
countPerDay[day]++;
currentDate.setDate(currentDate.getDate() + 1);
}
return countPerDay;
}
export function forecastPrinterUsage(jobs: InferResultType<"printJobs">[]): number[] {
const { usageData, earliestDate, latestDate } = aggregateUsageByDay(jobs);
// Count the number of times each weekday occurs in the data period
const weekdaysCount = countWeekdays(earliestDate, latestDate);
const forecasts: number[] = [];
for (const data of usageData) {
const dayCount = weekdaysCount[data.day];
let usagePrediction = data.usageMinutes / dayCount;
if (Number.isNaN(usagePrediction)) {
usagePrediction = 0;
}
forecasts.push(Math.round(usagePrediction));
}
return forecasts;
}

32
packages/reservation-platform/src/utils/analytics/utilization.ts
View File

@@ -1,32 +0,0 @@
import type { InferResultType } from "@/utils/drizzle";
export function calculatePrinterUtilization(jobs: InferResultType<"printJobs", { printer: true }>[]) {
const printers = jobs.reduce<Record<string, string>>((acc, job) => {
acc[job.printerId] = job.printer.name;
return acc;
}, {});
const usedTimePerPrinter: Record<string, number> = jobs.reduce(
(acc, job) => {
acc[job.printer.id] = (acc[job.printer.id] || 0) + job.durationInMinutes;
return acc;
},
{} as Record<string, number>,
);
const totalTimeInMinutes = 60 * 35 * 3; // 60 Minutes * 35h * 3 Weeks
// 35h Woche, 3 mal in der Woche in TBA
const printerUtilizationPercentage = Object.keys(usedTimePerPrinter).map((printerId) => {
const usedTime = usedTimePerPrinter[printerId];
return {
printerId,
name: printers[printerId],
utilizationPercentage: usedTime / totalTimeInMinutes,
};
});
return printerUtilizationPercentage;
}

52
packages/reservation-platform/src/utils/analytics/volume.ts
View File

@@ -1,52 +0,0 @@
import type { printJobs } from "@/server/db/schema";
import { endOfDay, endOfMonth, endOfWeek, startOfDay, startOfMonth, startOfWeek } from "date-fns";
import type { InferSelectModel } from "drizzle-orm";
interface PrintVolumes {
today: number;
thisWeek: number;
thisMonth: number;
}
/**
* Calculates the number of print jobs for today, this week, and this month.
*
* @param printJobs - Array of print job objects.
* @returns An object with counts of print jobs for today, this week, and this month.
*/
export function calculatePrintVolumes(pJobs: InferSelectModel<typeof printJobs>[]): PrintVolumes {
const now = new Date();
// Define time ranges with week starting on Monday
const timeRanges = {
today: { start: startOfDay(now), end: endOfDay(now) },
thisWeek: {
start: startOfWeek(now, { weekStartsOn: 1 }),
end: endOfWeek(now, { weekStartsOn: 1 }),
},
thisMonth: { start: startOfMonth(now), end: endOfMonth(now) },
};
// Initialize counts
const volumes: PrintVolumes = {
today: 0,
thisWeek: 0,
thisMonth: 0,
};
// Iterate over print jobs and count based on time ranges
for (const job of pJobs) {
const jobStart = new Date(job.startAt);
if (jobStart >= timeRanges.today.start && jobStart <= timeRanges.today.end) {
volumes.today += 1;
}
if (jobStart >= timeRanges.thisWeek.start && jobStart <= timeRanges.thisWeek.end) {
volumes.thisWeek += 1;
}
if (jobStart >= timeRanges.thisMonth.start && jobStart <= timeRanges.thisMonth.end) {
volumes.thisMonth += 1;
}
}
return volumes;
}

85
packages/reservation-platform/src/utils/backend-types.ts
View File

@@ -1,85 +0,0 @@
// TypeScript-Definitionen für die Backend-API-Responses
// Steckdosenmodell (entspricht dem Backend socket)
export interface BackendPrinter {
id: string;
name: string;
description: string;
status: number; // 0=available, 1=busy
ipAddress?: string;
connectionStatus?: string;
lastSeen?: string;
uptimeInfo?: {
offline_since?: string;
offline_duration?: number;
offline_duration_formatted?: string;
};
latestJob?: BackendJob | null;
waitingJobs?: BackendJob[];
}
// Druckauftrag (entspricht dem Backend job)
export interface BackendJob {
id: string;
socketId: string; // Backend nennt es socketId statt printerId
userId: string;
startAt: string;
durationInMinutes: number;
comments: string | null;
aborted: boolean;
abortReason: string | null;
waitingApproval?: boolean;
remainingMinutes?: number;
}
// Für die Kartierung zwischen Frontend und Backend
export const mapBackendPrinterToFrontend = (printer: BackendPrinter) => {
return {
id: printer.id,
name: printer.name,
description: printer.description,
status: printer.status,
// Weitere Felder für Frontend-Anpassungen
connectionStatus: printer.connectionStatus || 'unknown',
uptimeInfo: printer.uptimeInfo,
// Transformiere das aktuelle Job-Format
printJobs: printer.latestJob ? [mapBackendJobToFrontend(printer.latestJob)] : [],
// Weitere wartende Jobs
waitingJobs: printer.waitingJobs?.map(mapBackendJobToFrontend) || [],
};
};
export const mapFrontendPrinterToBackend = (printer: any) => {
return {
id: printer.id,
name: printer.name,
description: printer.description,
status: printer.status,
// Frontend hat keine IP-Adresse, diese wird vom Backend verwaltet
};
};
export const mapBackendJobToFrontend = (job: BackendJob) => {
return {
id: job.id,
printerId: job.socketId, // Anpassung des Feldnamens
userId: job.userId,
startAt: new Date(job.startAt),
durationInMinutes: job.durationInMinutes,
comments: job.comments || '',
aborted: job.aborted,
abortReason: job.abortReason || '',
waitingApproval: job.waitingApproval || false,
remainingMinutes: job.remainingMinutes || 0,
};
};
export const mapFrontendJobToBackend = (job: any) => {
return {
printerId: job.printerId, // Im Backend als socketId
userId: job.userId,
durationInMinutes: job.durationInMinutes,
comments: job.comments || '',
// Die restlichen Felder werden vom Backend verwaltet
};
};

0
packages/reservation-platform/src/utils/drizzle.ts Executable file → Normal file
View File

13
packages/reservation-platform/src/utils/env.ts Normal file
View File

@@ -0,0 +1,13 @@
import { z } from "zod";
/**
* Environment variables
*/
export const env = {
RUNTIME_ENVIRONMENT: z.enum(["prod", "dev"]).parse(process.env.RUNTIME_ENVIRONMENT),
DB_PATH: "db/sqlite.db", // As drizzle-kit currently can't load env variables, use a hardcoded value
OAUTH: {
CLIENT_ID: z.string().parse(process.env.OAUTH_CLIENT_ID),
CLIENT_SECRET: z.string().parse(process.env.OAUTH_CLIENT_SECRET),
},
};

0
packages/reservation-platform/src/utils/errors.ts Executable file → Normal file
View File

73
packages/reservation-platform/src/utils/fetch.ts Executable file → Normal file
View File

@@ -1,74 +1 @@
// Konfiguration für das Backend
export const BACKEND_URL = process.env.BACKEND_URL || 'http://localhost:5000';
// Standard Fetcher für SWR
export const fetcher = (url: string) => fetch(url).then((response) => response.json());
// Backend API Client für direkte API-Calls
export const backendFetcher = async (endpoint: string, options?: RequestInit) => {
const url = `${BACKEND_URL}${endpoint}`;
const response = await fetch(url, {
...options,
headers: {
'Content-Type': 'application/json',
...options?.headers,
},
});
if (!response.ok) {
throw new Error(`Backend API error: ${response.status} ${response.statusText}`);
}
return response.json();
};
// Backend API Wrapper mit spezifischen Endpunkten
export const backendApi = {
// Drucker-Endpunkte
printers: {
getAll: () => backendFetcher('/api/printers'),
getById: (id: string) => backendFetcher(`/api/printers/${id}`),
create: (data: any) => backendFetcher('/api/printers', {
method: 'POST',
body: JSON.stringify(data),
}),
update: (id: string, data: any) => backendFetcher(`/api/printers/${id}`, {
method: 'PUT',
body: JSON.stringify(data),
}),
delete: (id: string) => backendFetcher(`/api/printers/${id}`, {
method: 'DELETE',
}),
},
// Druckaufträge-Endpunkte
jobs: {
getAll: () => backendFetcher('/api/jobs'),
getById: (id: string) => backendFetcher(`/api/jobs/${id}`),
create: (data: any) => backendFetcher('/api/jobs', {
method: 'POST',
body: JSON.stringify(data),
}),
abort: (id: string, reason: string) => backendFetcher(`/api/jobs/${id}/abort`, {
method: 'POST',
body: JSON.stringify({ reason }),
}),
finish: (id: string) => backendFetcher(`/api/jobs/${id}/finish`, {
method: 'POST',
}),
extend: (id: string, minutes: number, hours: number) => backendFetcher(`/api/jobs/${id}/extend`, {
method: 'POST',
body: JSON.stringify({ minutes, hours }),
}),
updateComments: (id: string, comments: string) => backendFetcher(`/api/jobs/${id}/comments`, {
method: 'PUT',
body: JSON.stringify({ comments }),
}),
getRemainingTime: (id: string) => backendFetcher(`/api/job/${id}/remaining-time`),
},
// Statistiken-Endpunkt
stats: {
get: () => backendFetcher('/api/stats'),
},
};

0
packages/reservation-platform/src/utils/guard.ts Executable file → Normal file
View File

33
packages/reservation-platform/src/utils/heimdall.ts Normal file
View File

@@ -0,0 +1,33 @@
import type { UserRole } from "@/server/auth/permissions";
import type { users } from "@/server/db/schema";
import type { InferSelectModel } from "drizzle-orm";
import type { RegisteredDatabaseUserAttributes } from "lucia";
// Helpers to improve readability of the guard function
export const is = false;
export const is_not = true;
/**
* @deprecated
*/
export function guard(
user: RegisteredDatabaseUserAttributes | InferSelectModel<typeof users> | undefined | null,
negate: boolean,
roleRequirements: UserRole | UserRole[],
) {
if (!user) {
return true; // Guard against unauthenticated users
}
const hasRole = Array.isArray(roleRequirements)
? roleRequirements.includes(user?.role as UserRole)
: user?.role === roleRequirements;
return negate ? !hasRole : hasRole;
}
export class PermissionError extends Error {
constructor() {
super("Du besitzt nicht die erforderlichen Berechtigungen um diese Aktion auszuführen.");
}
}

0
packages/reservation-platform/src/utils/printers.ts Executable file → Normal file
View File

0
packages/reservation-platform/src/utils/strings.ts Executable file → Normal file
View File

0
packages/reservation-platform/src/utils/styles.ts Executable file → Normal file
View File