matthias/dashboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5add6590e55418896043c6f4cd08993840a865b0
dashboard/backend/src/controllers/bestellung.controller.ts
Matthias Hochmeister 5add6590e5 refactor external orders
2026-03-25 14:26:41 +01:00

513 lines
20 KiB
TypeScript
Raw Blame History

import { Request, Response } from 'express';
import bestellungService from '../services/bestellung.service';
import logger from '../utils/logger';
import fs from 'fs';
// Helper to safely extract a route param as string
const param = (req: Request, key: string): string => req.params[key] as string;
class BestellungController {
// ---------------------------------------------------------------------------
// Vendors
// ---------------------------------------------------------------------------
async listVendors(_req: Request, res: Response): Promise<void> {
try {
const vendors = await bestellungService.getVendors();
res.status(200).json({ success: true, data: vendors });
} catch (error) {
logger.error('BestellungController.listVendors error', { error });
res.status(500).json({ success: false, message: 'Lieferanten konnten nicht geladen werden' });
}
}
async getVendor(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
try {
const vendor = await bestellungService.getVendorById(id);
if (!vendor) {
res.status(404).json({ success: false, message: 'Lieferant nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: vendor });
} catch (error) {
logger.error('BestellungController.getVendor error', { error });
res.status(500).json({ success: false, message: 'Lieferant konnte nicht geladen werden' });
}
}
async getVendorOrders(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
try {
const orders = await bestellungService.getOrders({ lieferant_id: id });
res.status(200).json({ success: true, data: orders });
} catch (error) {
logger.error('BestellungController.getVendorOrders error', { error });
res.status(500).json({ success: false, message: 'Bestellungen konnten nicht geladen werden' });
}
}
async createVendor(req: Request, res: Response): Promise<void> {
const { name } = req.body;
if (!name || typeof name !== 'string' || name.trim().length === 0) {
res.status(400).json({ success: false, message: 'Name ist erforderlich' });
return;
}
try {
const vendor = await bestellungService.createVendor(req.body, req.user!.id);
res.status(201).json({ success: true, data: vendor });
} catch (error) {
logger.error('BestellungController.createVendor error', { error });
res.status(500).json({ success: false, message: 'Lieferant konnte nicht erstellt werden' });
}
}
async updateVendor(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
try {
const vendor = await bestellungService.updateVendor(id, req.body, req.user!.id);
if (!vendor) {
res.status(404).json({ success: false, message: 'Lieferant nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: vendor });
} catch (error) {
logger.error('BestellungController.updateVendor error', { error });
res.status(500).json({ success: false, message: 'Lieferant konnte nicht aktualisiert werden' });
}
}
async deleteVendor(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
try {
const deleted = await bestellungService.deleteVendor(id);
if (!deleted) {
res.status(404).json({ success: false, message: 'Lieferant nicht gefunden' });
return;
}
res.status(200).json({ success: true, message: 'Lieferant gelöscht' });
} catch (error) {
logger.error('BestellungController.deleteVendor error', { error });
res.status(500).json({ success: false, message: 'Lieferant konnte nicht gelöscht werden' });
}
}
// ---------------------------------------------------------------------------
// Orders
// ---------------------------------------------------------------------------
async listOrders(req: Request, res: Response): Promise<void> {
try {
const filters: { status?: string; lieferant_id?: number; besteller_id?: string } = {};
if (req.query.status) filters.status = req.query.status as string;
if (req.query.lieferant_id) filters.lieferant_id = parseInt(req.query.lieferant_id as string, 10);
if (req.query.besteller_id) filters.besteller_id = req.query.besteller_id as string;
const orders = await bestellungService.getOrders(filters);
res.status(200).json({ success: true, data: orders });
} catch (error) {
logger.error('BestellungController.listOrders error', { error });
res.status(500).json({ success: false, message: 'Bestellungen konnten nicht geladen werden' });
}
}
async getOrder(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
try {
const order = await bestellungService.getOrderById(id);
if (!order) {
res.status(404).json({ success: false, message: 'Bestellung nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: order });
} catch (error) {
logger.error('BestellungController.getOrder error', { error });
res.status(500).json({ success: false, message: 'Bestellung konnte nicht geladen werden' });
}
}
async createOrder(req: Request, res: Response): Promise<void> {
const { bezeichnung, lieferant_id, budget, besteller_id, positionen } = req.body;
if (!bezeichnung || typeof bezeichnung !== 'string' || bezeichnung.trim().length === 0) {
res.status(400).json({ success: false, message: 'Bezeichnung ist erforderlich' });
return;
}
if (lieferant_id != null && (!Number.isInteger(lieferant_id) || lieferant_id <= 0)) {
res.status(400).json({ success: false, message: 'Ungültige Lieferanten-ID' });
return;
}
if (budget != null && (typeof budget !== 'number' || budget < 0)) {
res.status(400).json({ success: false, message: 'Budget muss eine positive Zahl sein' });
return;
}
if (besteller_id != null && besteller_id !== '' && (typeof besteller_id !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(besteller_id))) {
res.status(400).json({ success: false, message: 'Ungültige Besteller-ID' });
return;
}
if (positionen != null && !Array.isArray(positionen)) {
res.status(400).json({ success: false, message: 'Positionen muss ein Array sein' });
return;
}
try {
const order = await bestellungService.createOrder(req.body, req.user!.id);
res.status(201).json({ success: true, data: order });
} catch (error) {
logger.error('BestellungController.createOrder error', { error });
res.status(500).json({ success: false, message: error instanceof Error ? error.message : 'Bestellung konnte nicht erstellt werden' });
}
}
async updateOrder(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
try {
const order = await bestellungService.updateOrder(id, req.body, req.user!.id);
if (!order) {
res.status(404).json({ success: false, message: 'Bestellung nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: order });
} catch (error) {
logger.error('BestellungController.updateOrder error', { error });
res.status(500).json({ success: false, message: 'Bestellung konnte nicht aktualisiert werden' });
}
}
async deleteOrder(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
try {
const deleted = await bestellungService.deleteOrder(id, req.user!.id);
if (!deleted) {
res.status(404).json({ success: false, message: 'Bestellung nicht gefunden' });
return;
}
res.status(200).json({ success: true, message: 'Bestellung gelöscht' });
} catch (error) {
logger.error('BestellungController.deleteOrder error', { error });
res.status(500).json({ success: false, message: 'Bestellung konnte nicht gelöscht werden' });
}
}
async updateStatus(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
const { status, force } = req.body;
if (!status || typeof status !== 'string') {
res.status(400).json({ success: false, message: 'Status ist erforderlich' });
return;
}
try {
const order = await bestellungService.updateOrderStatus(id, status, req.user!.id, !!force);
if (!order) {
res.status(404).json({ success: false, message: 'Bestellung nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: order });
} catch (error: any) {
if (error.message?.includes('Ungültiger Statusübergang')) {
res.status(400).json({ success: false, message: error.message });
return;
}
logger.error('BestellungController.updateStatus error', { error });
res.status(500).json({ success: false, message: 'Status konnte nicht aktualisiert werden' });
}
}
// ---------------------------------------------------------------------------
// Line Items
// ---------------------------------------------------------------------------
async addLineItem(req: Request, res: Response): Promise<void> {
const bestellungId = parseInt(param(req, 'id'), 10);
if (isNaN(bestellungId)) {
res.status(400).json({ success: false, message: 'Ungültige Bestellungs-ID' });
return;
}
const { bezeichnung, menge } = req.body;
if (!bezeichnung || typeof bezeichnung !== 'string' || bezeichnung.trim().length === 0) {
res.status(400).json({ success: false, message: 'Bezeichnung ist erforderlich' });
return;
}
if (menge === undefined || menge === null || menge <= 0) {
res.status(400).json({ success: false, message: 'Menge muss größer als 0 sein' });
return;
}
try {
const item = await bestellungService.addLineItem(bestellungId, req.body, req.user!.id);
res.status(201).json({ success: true, data: item });
} catch (error) {
logger.error('BestellungController.addLineItem error', { error });
res.status(500).json({ success: false, message: 'Position konnte nicht hinzugefügt werden' });
}
}
async updateLineItem(req: Request, res: Response): Promise<void> {
const itemId = parseInt(param(req, 'itemId'), 10);
if (isNaN(itemId)) {
res.status(400).json({ success: false, message: 'Ungültige Position-ID' });
return;
}
try {
const item = await bestellungService.updateLineItem(itemId, req.body, req.user!.id);
if (!item) {
res.status(404).json({ success: false, message: 'Position nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: item });
} catch (error) {
logger.error('BestellungController.updateLineItem error', { error });
res.status(500).json({ success: false, message: 'Position konnte nicht aktualisiert werden' });
}
}
async deleteLineItem(req: Request, res: Response): Promise<void> {
const itemId = parseInt(param(req, 'itemId'), 10);
if (isNaN(itemId)) {
res.status(400).json({ success: false, message: 'Ungültige Position-ID' });
return;
}
try {
const deleted = await bestellungService.deleteLineItem(itemId, req.user!.id);
if (!deleted) {
res.status(404).json({ success: false, message: 'Position nicht gefunden' });
return;
}
res.status(200).json({ success: true, message: 'Position gelöscht' });
} catch (error) {
logger.error('BestellungController.deleteLineItem error', { error });
res.status(500).json({ success: false, message: 'Position konnte nicht gelöscht werden' });
}
}
async updateReceivedQuantity(req: Request, res: Response): Promise<void> {
const itemId = parseInt(param(req, 'itemId'), 10);
if (isNaN(itemId)) {
res.status(400).json({ success: false, message: 'Ungültige Position-ID' });
return;
}
const { menge } = req.body;
if (menge === undefined || menge === null || menge < 0) {
res.status(400).json({ success: false, message: 'Erhaltene Menge muss >= 0 sein' });
return;
}
try {
const item = await bestellungService.updateReceivedQuantity(itemId, menge, req.user!.id);
if (!item) {
res.status(404).json({ success: false, message: 'Position nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: item });
} catch (error) {
logger.error('BestellungController.updateReceivedQuantity error', { error });
res.status(500).json({ success: false, message: 'Liefermenge konnte nicht aktualisiert werden' });
}
}
// ---------------------------------------------------------------------------
// Files
// ---------------------------------------------------------------------------
async uploadFile(req: Request, res: Response): Promise<void> {
const bestellungId = parseInt(param(req, 'id'), 10);
if (isNaN(bestellungId)) {
res.status(400).json({ success: false, message: 'Ungültige Bestellungs-ID' });
return;
}
const file = (req as any).file;
if (!file) {
res.status(400).json({ success: false, message: 'Keine Datei hochgeladen' });
return;
}
try {
const fileRecord = await bestellungService.addFile(bestellungId, {
dateiname: file.originalname,
dateipfad: file.path,
dateityp: file.mimetype,
dateigroesse: file.size,
}, req.user!.id);
res.status(201).json({ success: true, data: fileRecord });
} catch (error) {
logger.error('BestellungController.uploadFile error', { error });
res.status(500).json({ success: false, message: 'Datei konnte nicht hochgeladen werden' });
}
}
async deleteFile(req: Request, res: Response): Promise<void> {
const fileId = parseInt(param(req, 'fileId'), 10);
if (isNaN(fileId)) {
res.status(400).json({ success: false, message: 'Ungültige Datei-ID' });
return;
}
try {
const result = await bestellungService.deleteFile(fileId, req.user!.id);
if (!result) {
res.status(404).json({ success: false, message: 'Datei nicht gefunden' });
return;
}
// Remove from disk
try {
if (result.dateipfad && fs.existsSync(result.dateipfad)) {
fs.unlinkSync(result.dateipfad);
}
} catch (err) {
logger.warn('Failed to delete file from disk', { path: result.dateipfad, error: err });
}
res.status(200).json({ success: true, message: 'Datei gelöscht' });
} catch (error) {
logger.error('BestellungController.deleteFile error', { error });
res.status(500).json({ success: false, message: 'Datei konnte nicht gelöscht werden' });
}
}
async listFiles(req: Request, res: Response): Promise<void> {
const bestellungId = parseInt(param(req, 'id'), 10);
if (isNaN(bestellungId)) {
res.status(400).json({ success: false, message: 'Ungültige Bestellungs-ID' });
return;
}
try {
const files = await bestellungService.getFilesByOrder(bestellungId);
res.status(200).json({ success: true, data: files });
} catch (error) {
logger.error('BestellungController.listFiles error', { error });
res.status(500).json({ success: false, message: 'Dateien konnten nicht geladen werden' });
}
}
// ---------------------------------------------------------------------------
// Reminders
// ---------------------------------------------------------------------------
async addReminder(req: Request, res: Response): Promise<void> {
const bestellungId = parseInt(param(req, 'id'), 10);
if (isNaN(bestellungId)) {
res.status(400).json({ success: false, message: 'Ungültige Bestellungs-ID' });
return;
}
const { faellig_am } = req.body;
if (!faellig_am) {
res.status(400).json({ success: false, message: 'Fälligkeitsdatum ist erforderlich' });
return;
}
try {
const reminder = await bestellungService.addReminder(bestellungId, req.body, req.user!.id);
res.status(201).json({ success: true, data: reminder });
} catch (error) {
logger.error('BestellungController.addReminder error', { error });
res.status(500).json({ success: false, message: 'Erinnerung konnte nicht erstellt werden' });
}
}
async markReminderDone(req: Request, res: Response): Promise<void> {
const remId = parseInt(param(req, 'remId'), 10);
if (isNaN(remId)) {
res.status(400).json({ success: false, message: 'Ungültige Erinnerungs-ID' });
return;
}
try {
const reminder = await bestellungService.markReminderDone(remId, req.user!.id);
if (!reminder) {
res.status(404).json({ success: false, message: 'Erinnerung nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: reminder });
} catch (error) {
logger.error('BestellungController.markReminderDone error', { error });
res.status(500).json({ success: false, message: 'Erinnerung konnte nicht als erledigt markiert werden' });
}
}
async deleteReminder(req: Request, res: Response): Promise<void> {
const remId = parseInt(param(req, 'remId'), 10);
if (isNaN(remId)) {
res.status(400).json({ success: false, message: 'Ungültige Erinnerungs-ID' });
return;
}
try {
const deleted = await bestellungService.deleteReminder(remId);
if (!deleted) {
res.status(404).json({ success: false, message: 'Erinnerung nicht gefunden' });
return;
}
res.status(200).json({ success: true, message: 'Erinnerung gelöscht' });
} catch (error) {
logger.error('BestellungController.deleteReminder error', { error });
res.status(500).json({ success: false, message: 'Erinnerung konnte nicht gelöscht werden' });
}
}
// ---------------------------------------------------------------------------
// History
// ---------------------------------------------------------------------------
async getHistory(req: Request, res: Response): Promise<void> {
const bestellungId = parseInt(param(req, 'id'), 10);
if (isNaN(bestellungId)) {
res.status(400).json({ success: false, message: 'Ungültige Bestellungs-ID' });
return;
}
try {
const history = await bestellungService.getHistory(bestellungId);
res.status(200).json({ success: true, data: history });
} catch (error) {
logger.error('BestellungController.getHistory error', { error });
res.status(500).json({ success: false, message: 'Historie konnte nicht geladen werden' });
}
}
// ---------------------------------------------------------------------------
// Export (placeholder — returns order detail as JSON for now)
// ---------------------------------------------------------------------------
async exportOrder(req: Request, res: Response): Promise<void> {
const id = parseInt(param(req, 'id'), 10);
if (isNaN(id)) {
res.status(400).json({ success: false, message: 'Ungültige ID' });
return;
}
try {
const order = await bestellungService.getOrderById(id);
if (!order) {
res.status(404).json({ success: false, message: 'Bestellung nicht gefunden' });
return;
}
res.status(200).json({ success: true, data: order });
} catch (error) {
logger.error('BestellungController.exportOrder error', { error });
res.status(500).json({ success: false, message: 'Export fehlgeschlagen' });
}
}
}
export default new BestellungController();
Reference in New Issue View Git Blame Copy Permalink