1030 lines
39 KiB
TypeScript
1030 lines
39 KiB
TypeScript
import { Request, Response } from 'express';
|
|
import prisma from '../lib/prisma.js';
|
|
import * as customerService from '../services/customer.service.js';
|
|
import * as authService from '../services/auth.service.js';
|
|
import { logChange } from '../services/audit.service.js';
|
|
import { ApiResponse, AuthRequest } from '../types/index.js';
|
|
|
|
// Customer CRUD
|
|
export async function getCustomers(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const { search, type, page, limit } = req.query;
|
|
const result = await customerService.getAllCustomers({
|
|
search: search as string,
|
|
type: type as 'PRIVATE' | 'BUSINESS',
|
|
page: page ? parseInt(page as string) : undefined,
|
|
limit: limit ? parseInt(limit as string) : undefined,
|
|
});
|
|
res.json({ success: true, data: result.customers, pagination: result.pagination } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Fehler beim Laden der Kunden',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function getCustomer(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customer = await customerService.getCustomerById(parseInt(req.params.id));
|
|
if (!customer) {
|
|
res.status(404).json({ success: false, error: 'Kunde nicht gefunden' } as ApiResponse);
|
|
return;
|
|
}
|
|
res.json({ success: true, data: customer } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({ success: false, error: 'Fehler beim Laden des Kunden' } as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function createCustomer(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const data = { ...req.body };
|
|
// Convert birthDate string to Date if present
|
|
if (data.birthDate) {
|
|
data.birthDate = new Date(data.birthDate);
|
|
}
|
|
const customer = await customerService.createCustomer(data);
|
|
await logChange({
|
|
req, action: 'CREATE', resourceType: 'Customer',
|
|
resourceId: customer.id.toString(),
|
|
label: `Kunde ${customer.customerNumber} angelegt (${customer.firstName} ${customer.lastName})`,
|
|
customerId: customer.id,
|
|
});
|
|
res.status(201).json({ success: true, data: customer } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Erstellen des Kunden',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function updateCustomer(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.id);
|
|
const data = { ...req.body };
|
|
|
|
// Vorherigen Stand laden für Audit
|
|
const before = await prisma.customer.findUnique({ where: { id: customerId } });
|
|
|
|
// Convert birthDate string to Date if present, empty string to null
|
|
if (data.birthDate === '' || data.birthDate === null) {
|
|
data.birthDate = null;
|
|
} else if (data.birthDate) {
|
|
data.birthDate = new Date(data.birthDate);
|
|
}
|
|
// Leere Strings in optionalen Feldern zu null konvertieren
|
|
const nullableFields = ['salutation', 'birthPlace', 'phone', 'mobile', 'email', 'companyName', 'taxNumber', 'businessRegistration', 'commercialRegister', 'commercialRegisterNumber', 'notes'];
|
|
for (const field of nullableFields) {
|
|
if (data[field] === '') data[field] = null;
|
|
}
|
|
const customer = await customerService.updateCustomer(customerId, data);
|
|
|
|
// Audit: Geänderte Felder ermitteln und loggen
|
|
if (before) {
|
|
const changes: Record<string, { von: unknown; nach: unknown }> = {};
|
|
const fieldLabels: Record<string, string> = {
|
|
salutation: 'Anrede', firstName: 'Vorname', lastName: 'Nachname', email: 'E-Mail',
|
|
phone: 'Telefon', mobile: 'Mobil', birthDate: 'Geburtsdatum', birthPlace: 'Geburtsort',
|
|
companyName: 'Firma', type: 'Typ', taxNumber: 'Steuernummer', notes: 'Notizen',
|
|
useInformalAddress: 'Anrede per',
|
|
autoBirthdayGreeting: 'Autom. Geburtstagsgruß',
|
|
autoBirthdayChannel: 'Kanal für Geburtstagsgruß',
|
|
};
|
|
for (const [key, value] of Object.entries(data)) {
|
|
// Technische/interne Felder überspringen
|
|
if (['id', 'createdAt', 'updatedAt', 'customerNumber', 'portalPasswordHash', 'portalPasswordEncrypted'].includes(key)) continue;
|
|
|
|
const oldVal = (before as any)[key];
|
|
const newVal = value;
|
|
// Normalisieren: null, undefined, "" werden alle als "leer" behandelt
|
|
const normalize = (v: unknown) => {
|
|
if (v === null || v === undefined || v === '') return null;
|
|
if (v instanceof Date) return v.toISOString().split('T')[0];
|
|
return v;
|
|
};
|
|
const oldNorm = normalize(oldVal);
|
|
const newNorm = normalize(newVal);
|
|
if (JSON.stringify(oldNorm) !== JSON.stringify(newNorm)) {
|
|
const label = fieldLabels[key] || key;
|
|
const formatVal = (v: unknown) => {
|
|
if (v === null || v === undefined || v === '') return '-';
|
|
if (v instanceof Date) return v.toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit', year: 'numeric' });
|
|
if (typeof v === 'boolean') return v ? 'Ja' : 'Nein';
|
|
return String(v);
|
|
};
|
|
changes[label] = { von: formatVal(oldVal), nach: formatVal(newVal) };
|
|
}
|
|
}
|
|
if (Object.keys(changes).length > 0) {
|
|
const changeList = Object.entries(changes).map(([f, c]) => `${f}: ${c.von} → ${c.nach}`).join(', ');
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'Customer',
|
|
resourceId: customerId.toString(),
|
|
label: `Kunde ${before.customerNumber} aktualisiert: ${changeList}`,
|
|
details: changes,
|
|
customerId,
|
|
});
|
|
}
|
|
}
|
|
|
|
res.json({ success: true, data: customer } as ApiResponse);
|
|
} catch (error) {
|
|
console.error('Update customer error:', error);
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren des Kunden',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function deleteCustomer(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.id);
|
|
const customer = await prisma.customer.findUnique({ where: { id: customerId }, select: { customerNumber: true, firstName: true, lastName: true } });
|
|
await customerService.deleteCustomer(customerId);
|
|
await logChange({
|
|
req, action: 'DELETE', resourceType: 'Customer',
|
|
resourceId: customerId.toString(),
|
|
label: `Kunde ${customer?.customerNumber} gelöscht (${customer?.firstName} ${customer?.lastName})`,
|
|
customerId,
|
|
});
|
|
res.json({ success: true, message: 'Kunde gelöscht' } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Löschen des Kunden',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
// Addresses
|
|
export async function getAddresses(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const addresses = await customerService.getCustomerAddresses(parseInt(req.params.customerId));
|
|
res.json({ success: true, data: addresses } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({ success: false, error: 'Fehler beim Laden der Adressen' } as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function createAddress(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.customerId);
|
|
const address = await customerService.createAddress(customerId, req.body);
|
|
await logChange({
|
|
req, action: 'CREATE', resourceType: 'Address',
|
|
resourceId: address.id.toString(),
|
|
label: `Adresse hinzugefügt für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
res.status(201).json({ success: true, data: address } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Erstellen der Adresse',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function updateAddress(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const addressId = parseInt(req.params.id);
|
|
const data = req.body;
|
|
|
|
// Vorherigen Stand laden für Audit
|
|
const before = await prisma.address.findUnique({ where: { id: addressId } });
|
|
|
|
const address = await customerService.updateAddress(addressId, data);
|
|
const customerId = address.customerId;
|
|
|
|
// Audit: Geänderte Felder ermitteln und loggen
|
|
if (before) {
|
|
const changes: Record<string, { von: unknown; nach: unknown }> = {};
|
|
const fieldLabels: Record<string, string> = {
|
|
street: 'Straße', houseNumber: 'Hausnummer', postalCode: 'PLZ',
|
|
city: 'Stadt', country: 'Land', type: 'Typ', isDefault: 'Standard',
|
|
ownerCompany: 'Eigentümer Firma', ownerFirstName: 'Eigentümer Vorname',
|
|
ownerLastName: 'Eigentümer Nachname', ownerStreet: 'Eigentümer Straße',
|
|
ownerHouseNumber: 'Eigentümer Hausnr.', ownerPostalCode: 'Eigentümer PLZ',
|
|
ownerCity: 'Eigentümer Ort', ownerPhone: 'Eigentümer Telefon',
|
|
ownerMobile: 'Eigentümer Mobil', ownerEmail: 'Eigentümer E-Mail',
|
|
};
|
|
for (const [key, newVal] of Object.entries(data)) {
|
|
if (['id', 'createdAt', 'updatedAt'].includes(key)) continue;
|
|
const oldVal = (before as any)[key];
|
|
const norm = (v: unknown) => (v === null || v === undefined || v === '' ? null : v);
|
|
if (JSON.stringify(norm(oldVal)) !== JSON.stringify(norm(newVal))) {
|
|
const label = fieldLabels[key] || key;
|
|
const formatVal = (v: unknown) => {
|
|
if (v === null || v === undefined || v === '') return '-';
|
|
if (typeof v === 'boolean') return v ? 'Ja' : 'Nein';
|
|
return String(v);
|
|
};
|
|
changes[label] = { von: formatVal(oldVal), nach: formatVal(newVal) };
|
|
}
|
|
}
|
|
const changeList = Object.entries(changes).map(([f, c]) => `${f}: ${c.von} → ${c.nach}`).join(', ');
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'Address',
|
|
resourceId: address.id.toString(),
|
|
label: changeList ? `Adresse aktualisiert für Kunde #${customerId}: ${changeList}` : `Adresse aktualisiert für Kunde #${customerId}`,
|
|
details: Object.keys(changes).length > 0 ? changes : undefined,
|
|
customerId,
|
|
});
|
|
} else {
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'Address',
|
|
resourceId: address.id.toString(),
|
|
label: `Adresse aktualisiert für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
}
|
|
|
|
res.json({ success: true, data: address } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren der Adresse',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function deleteAddress(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const addressId = parseInt(req.params.id);
|
|
const addr = await prisma.address.findUnique({ where: { id: addressId }, select: { customerId: true } });
|
|
const customerId = addr?.customerId;
|
|
await customerService.deleteAddress(addressId);
|
|
await logChange({
|
|
req, action: 'DELETE', resourceType: 'Address',
|
|
resourceId: addressId.toString(),
|
|
label: `Adresse gelöscht für Kunde #${customerId}`,
|
|
customerId: customerId ?? undefined,
|
|
});
|
|
res.json({ success: true, message: 'Adresse gelöscht' } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Löschen der Adresse',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
// Bank Cards
|
|
export async function getBankCards(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const showInactive = req.query.showInactive === 'true';
|
|
const cards = await customerService.getCustomerBankCards(
|
|
parseInt(req.params.customerId),
|
|
showInactive
|
|
);
|
|
res.json({ success: true, data: cards } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({ success: false, error: 'Fehler beim Laden der Bankkarten' } as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function createBankCard(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.customerId);
|
|
const card = await customerService.createBankCard(customerId, req.body);
|
|
await logChange({
|
|
req, action: 'CREATE', resourceType: 'BankCard',
|
|
resourceId: card.id.toString(),
|
|
label: `Bankverbindung hinzugefügt für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
res.status(201).json({ success: true, data: card } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Erstellen der Bankkarte',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function updateBankCard(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const cardId = parseInt(req.params.id);
|
|
const data = req.body;
|
|
|
|
// Vorherigen Stand laden für Audit
|
|
const before = await prisma.bankCard.findUnique({ where: { id: cardId } });
|
|
|
|
const card = await customerService.updateBankCard(cardId, data);
|
|
const customerId = card.customerId;
|
|
|
|
// Audit: Geänderte Felder ermitteln und loggen
|
|
if (before) {
|
|
const changes: Record<string, { von: unknown; nach: unknown }> = {};
|
|
const fieldLabels: Record<string, string> = {
|
|
iban: 'IBAN', bic: 'BIC', bankName: 'Bank',
|
|
accountHolder: 'Kontoinhaber', isActive: 'Aktiv',
|
|
};
|
|
for (const [key, newVal] of Object.entries(data)) {
|
|
if (['id', 'createdAt', 'updatedAt'].includes(key)) continue;
|
|
const oldVal = (before as any)[key];
|
|
const norm = (v: unknown) => (v === null || v === undefined || v === '' ? null : v);
|
|
if (JSON.stringify(norm(oldVal)) !== JSON.stringify(norm(newVal))) {
|
|
const label = fieldLabels[key] || key;
|
|
const formatVal = (v: unknown) => {
|
|
if (v === null || v === undefined || v === '') return '-';
|
|
if (typeof v === 'boolean') return v ? 'Ja' : 'Nein';
|
|
return String(v);
|
|
};
|
|
changes[label] = { von: formatVal(oldVal), nach: formatVal(newVal) };
|
|
}
|
|
}
|
|
const changeList = Object.entries(changes).map(([f, c]) => `${f}: ${c.von} → ${c.nach}`).join(', ');
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'BankCard',
|
|
resourceId: card.id.toString(),
|
|
label: changeList ? `Bankverbindung aktualisiert für Kunde #${customerId}: ${changeList}` : `Bankverbindung aktualisiert für Kunde #${customerId}`,
|
|
details: Object.keys(changes).length > 0 ? changes : undefined,
|
|
customerId,
|
|
});
|
|
} else {
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'BankCard',
|
|
resourceId: card.id.toString(),
|
|
label: `Bankverbindung aktualisiert für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
}
|
|
|
|
res.json({ success: true, data: card } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren der Bankkarte',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function deleteBankCard(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const cardId = parseInt(req.params.id);
|
|
const card = await prisma.bankCard.findUnique({ where: { id: cardId }, select: { customerId: true } });
|
|
const customerId = card?.customerId;
|
|
await customerService.deleteBankCard(cardId);
|
|
await logChange({
|
|
req, action: 'DELETE', resourceType: 'BankCard',
|
|
resourceId: cardId.toString(),
|
|
label: `Bankverbindung gelöscht für Kunde #${customerId}`,
|
|
customerId: customerId ?? undefined,
|
|
});
|
|
res.json({ success: true, message: 'Bankkarte gelöscht' } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Löschen der Bankkarte',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
// Identity Documents
|
|
export async function getDocuments(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const showInactive = req.query.showInactive === 'true';
|
|
const docs = await customerService.getCustomerDocuments(
|
|
parseInt(req.params.customerId),
|
|
showInactive
|
|
);
|
|
res.json({ success: true, data: docs } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({ success: false, error: 'Fehler beim Laden der Ausweise' } as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function createDocument(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.customerId);
|
|
const doc = await customerService.createDocument(customerId, req.body);
|
|
await logChange({
|
|
req, action: 'CREATE', resourceType: 'IdentityDocument',
|
|
resourceId: doc.id.toString(),
|
|
label: `Ausweis hinzugefügt für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
res.status(201).json({ success: true, data: doc } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Erstellen des Ausweises',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function updateDocument(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const docId = parseInt(req.params.id);
|
|
const data = req.body;
|
|
|
|
// Vorherigen Stand laden für Audit
|
|
const before = await prisma.identityDocument.findUnique({ where: { id: docId } });
|
|
|
|
const doc = await customerService.updateDocument(docId, data);
|
|
const customerId = doc.customerId;
|
|
|
|
// Audit: Geänderte Felder ermitteln und loggen
|
|
if (before) {
|
|
const changes: Record<string, { von: unknown; nach: unknown }> = {};
|
|
const fieldLabels: Record<string, string> = {
|
|
type: 'Dokumenttyp', documentNumber: 'Dokumentnummer',
|
|
issuingAuthority: 'Ausstellungsbehörde', issueDate: 'Ausstellungsdatum',
|
|
expiryDate: 'Ablaufdatum', isActive: 'Aktiv', licenseClasses: 'Führerscheinklassen',
|
|
};
|
|
for (const [key, newVal] of Object.entries(data)) {
|
|
if (['id', 'createdAt', 'updatedAt'].includes(key)) continue;
|
|
const oldVal = (before as any)[key];
|
|
const norm = (v: unknown) => {
|
|
if (v === null || v === undefined || v === '') return null;
|
|
if (v instanceof Date) return v.toISOString().split('T')[0];
|
|
return v;
|
|
};
|
|
if (JSON.stringify(norm(oldVal)) !== JSON.stringify(norm(newVal))) {
|
|
const label = fieldLabels[key] || key;
|
|
const formatVal = (v: unknown) => {
|
|
if (v === null || v === undefined || v === '') return '-';
|
|
if (v instanceof Date) return v.toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit', year: 'numeric' });
|
|
if (typeof v === 'boolean') return v ? 'Ja' : 'Nein';
|
|
return String(v);
|
|
};
|
|
changes[label] = { von: formatVal(oldVal), nach: formatVal(newVal) };
|
|
}
|
|
}
|
|
const changeList = Object.entries(changes).map(([f, c]) => `${f}: ${c.von} → ${c.nach}`).join(', ');
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'IdentityDocument',
|
|
resourceId: doc.id.toString(),
|
|
label: changeList ? `Ausweis aktualisiert für Kunde #${customerId}: ${changeList}` : `Ausweis aktualisiert für Kunde #${customerId}`,
|
|
details: Object.keys(changes).length > 0 ? changes : undefined,
|
|
customerId,
|
|
});
|
|
} else {
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'IdentityDocument',
|
|
resourceId: doc.id.toString(),
|
|
label: `Ausweis aktualisiert für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
}
|
|
|
|
res.json({ success: true, data: doc } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren des Ausweises',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function deleteDocument(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const docId = parseInt(req.params.id);
|
|
const doc = await prisma.identityDocument.findUnique({ where: { id: docId }, select: { customerId: true } });
|
|
const customerId = doc?.customerId;
|
|
await customerService.deleteDocument(docId);
|
|
await logChange({
|
|
req, action: 'DELETE', resourceType: 'IdentityDocument',
|
|
resourceId: docId.toString(),
|
|
label: `Ausweis gelöscht für Kunde #${customerId}`,
|
|
customerId: customerId ?? undefined,
|
|
});
|
|
res.json({ success: true, message: 'Ausweis gelöscht' } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Löschen des Ausweises',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
// Meters
|
|
export async function getMeters(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const showInactive = req.query.showInactive === 'true';
|
|
const meters = await customerService.getCustomerMeters(
|
|
parseInt(req.params.customerId),
|
|
showInactive
|
|
);
|
|
res.json({ success: true, data: meters } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({ success: false, error: 'Fehler beim Laden der Zähler' } as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function createMeter(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.customerId);
|
|
const meter = await customerService.createMeter(customerId, req.body);
|
|
await logChange({
|
|
req, action: 'CREATE', resourceType: 'Meter',
|
|
resourceId: meter.id.toString(),
|
|
label: `Zähler angelegt für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
res.status(201).json({ success: true, data: meter } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Erstellen des Zählers',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function updateMeter(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const meterId = parseInt(req.params.id);
|
|
const data = req.body;
|
|
|
|
// Vorherigen Stand laden für Audit
|
|
const before = await prisma.meter.findUnique({ where: { id: meterId } });
|
|
|
|
const meter = await customerService.updateMeter(meterId, data);
|
|
const customerId = meter.customerId;
|
|
|
|
// Audit: Geänderte Felder ermitteln und loggen
|
|
if (before) {
|
|
const changes: Record<string, { von: unknown; nach: unknown }> = {};
|
|
const fieldLabels: Record<string, string> = {
|
|
meterNumber: 'Zählernummer', type: 'Typ', tariffModel: 'Tarifmodell',
|
|
location: 'Standort', isActive: 'Aktiv',
|
|
};
|
|
for (const [key, newVal] of Object.entries(data)) {
|
|
if (['id', 'createdAt', 'updatedAt'].includes(key)) continue;
|
|
const oldVal = (before as any)[key];
|
|
const norm = (v: unknown) => (v === null || v === undefined || v === '' ? null : v);
|
|
if (JSON.stringify(norm(oldVal)) !== JSON.stringify(norm(newVal))) {
|
|
const label = fieldLabels[key] || key;
|
|
const formatVal = (v: unknown) => {
|
|
if (v === null || v === undefined || v === '') return '-';
|
|
if (typeof v === 'boolean') return v ? 'Ja' : 'Nein';
|
|
return String(v);
|
|
};
|
|
changes[label] = { von: formatVal(oldVal), nach: formatVal(newVal) };
|
|
}
|
|
}
|
|
const changeList = Object.entries(changes).map(([f, c]) => `${f}: ${c.von} → ${c.nach}`).join(', ');
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'Meter',
|
|
resourceId: meter.id.toString(),
|
|
label: changeList ? `Zähler aktualisiert: ${changeList}` : `Zähler aktualisiert`,
|
|
details: Object.keys(changes).length > 0 ? changes : undefined,
|
|
customerId,
|
|
});
|
|
} else {
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'Meter',
|
|
resourceId: meter.id.toString(),
|
|
label: `Zähler aktualisiert`,
|
|
});
|
|
}
|
|
|
|
res.json({ success: true, data: meter } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren des Zählers',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function deleteMeter(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const meterId = parseInt(req.params.id);
|
|
await customerService.deleteMeter(meterId);
|
|
await logChange({
|
|
req, action: 'DELETE', resourceType: 'Meter',
|
|
resourceId: meterId.toString(),
|
|
label: `Zähler gelöscht`,
|
|
});
|
|
res.json({ success: true, message: 'Zähler gelöscht' } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Löschen des Zählers',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
// Meter Readings
|
|
export async function getMeterReadings(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const readings = await customerService.getMeterReadings(parseInt(req.params.meterId));
|
|
res.json({ success: true, data: readings } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({ success: false, error: 'Fehler beim Laden der Zählerstände' } as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function addMeterReading(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const { readingDate, value, valueNt, unit, notes } = req.body;
|
|
const meterId = parseInt(req.params.meterId);
|
|
const reading = await customerService.addMeterReading(meterId, {
|
|
readingDate: new Date(readingDate),
|
|
value: parseFloat(value),
|
|
valueNt: valueNt !== undefined && valueNt !== null && valueNt !== '' ? parseFloat(valueNt) : undefined,
|
|
unit,
|
|
notes,
|
|
});
|
|
|
|
// Audit: Zählerstand mit Kontext loggen
|
|
const meter = await prisma.meter.findUnique({
|
|
where: { id: meterId },
|
|
select: { meterNumber: true, customer: { select: { id: true, firstName: true, lastName: true } } },
|
|
});
|
|
if (meter) {
|
|
const ntInfo = valueNt ? ` / NT: ${parseFloat(valueNt)}` : '';
|
|
await logChange({
|
|
req, action: 'CREATE', resourceType: 'MeterReading',
|
|
label: `Zählerstand ${parseFloat(value)}${ntInfo} ${unit || 'kWh'} für Zähler ${meter.meterNumber} erfasst (${meter.customer.firstName} ${meter.customer.lastName})`,
|
|
details: { zähler: meter.meterNumber, stand: parseFloat(value), datum: readingDate },
|
|
customerId: meter.customer.id,
|
|
});
|
|
}
|
|
|
|
res.status(201).json({ success: true, data: reading } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Hinzufügen des Zählerstands',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function updateMeterReading(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const { readingDate, value, valueNt, unit, notes } = req.body;
|
|
const updateData: Record<string, unknown> = {};
|
|
if (readingDate !== undefined) updateData.readingDate = new Date(readingDate);
|
|
if (value !== undefined) updateData.value = parseFloat(value);
|
|
if (valueNt !== undefined) updateData.valueNt = valueNt !== null && valueNt !== '' ? parseFloat(valueNt) : null;
|
|
if (unit !== undefined) updateData.unit = unit;
|
|
if (notes !== undefined) updateData.notes = notes;
|
|
|
|
const reading = await customerService.updateMeterReading(
|
|
parseInt(req.params.meterId),
|
|
parseInt(req.params.readingId),
|
|
updateData as any
|
|
);
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'MeterReading',
|
|
resourceId: reading.id.toString(),
|
|
label: `Zählerstand aktualisiert`,
|
|
});
|
|
res.json({ success: true, data: reading } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren des Zählerstands',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function deleteMeterReading(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const readingId = parseInt(req.params.readingId);
|
|
await customerService.deleteMeterReading(
|
|
parseInt(req.params.meterId),
|
|
readingId
|
|
);
|
|
await logChange({
|
|
req, action: 'DELETE', resourceType: 'MeterReading',
|
|
resourceId: readingId.toString(),
|
|
label: `Zählerstand gelöscht`,
|
|
});
|
|
res.json({ success: true, data: null } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Löschen des Zählerstands',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
// ==================== PORTAL: ZÄHLERSTAND MELDEN ====================
|
|
|
|
export async function reportMeterReading(req: AuthRequest, res: Response): Promise<void> {
|
|
try {
|
|
const user = req.user as any;
|
|
if (!user?.isCustomerPortal || !user?.customerId) {
|
|
res.status(403).json({ success: false, error: 'Nur für Kundenportal-Benutzer' } as ApiResponse);
|
|
return;
|
|
}
|
|
|
|
const meterId = parseInt(req.params.meterId);
|
|
const { value, readingDate, notes } = req.body;
|
|
|
|
// Prüfe ob der Zähler zum Kunden gehört
|
|
const meter = await prisma.meter.findUnique({
|
|
where: { id: meterId },
|
|
select: { customerId: true },
|
|
});
|
|
|
|
if (!meter || meter.customerId !== user.customerId) {
|
|
res.status(403).json({ success: false, error: 'Kein Zugriff auf diesen Zähler' } as ApiResponse);
|
|
return;
|
|
}
|
|
|
|
const parsedDate = readingDate ? new Date(readingDate) : new Date();
|
|
const parsedValue = parseFloat(value);
|
|
|
|
// Validierung über den Service (monoton steigend)
|
|
const reading = await customerService.addMeterReading(meterId, {
|
|
readingDate: parsedDate,
|
|
value: parsedValue,
|
|
notes,
|
|
});
|
|
|
|
// Status auf REPORTED setzen
|
|
await prisma.meterReading.update({
|
|
where: { id: reading.id },
|
|
data: { reportedBy: user.email, status: 'REPORTED' },
|
|
});
|
|
|
|
// Audit
|
|
const meterInfo = await prisma.meter.findUnique({ where: { id: meterId }, select: { meterNumber: true } });
|
|
await logChange({
|
|
req, action: 'CREATE', resourceType: 'MeterReading',
|
|
label: `Zählerstand ${parsedValue} gemeldet (Zähler ${meterInfo?.meterNumber || meterId})`,
|
|
details: { zähler: meterInfo?.meterNumber, stand: parsedValue, datum: parsedDate.toISOString() },
|
|
customerId: user.customerId,
|
|
});
|
|
|
|
res.status(201).json({ success: true, data: reading } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Melden des Zählerstands',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function getMyMeters(req: AuthRequest, res: Response): Promise<void> {
|
|
try {
|
|
const user = req.user as any;
|
|
if (!user?.isCustomerPortal || !user?.customerId) {
|
|
res.status(403).json({ success: false, error: 'Nur für Kundenportal-Benutzer' } as ApiResponse);
|
|
return;
|
|
}
|
|
|
|
const meters = await prisma.meter.findMany({
|
|
where: { customerId: user.customerId, isActive: true },
|
|
include: {
|
|
readings: {
|
|
orderBy: { readingDate: 'desc' },
|
|
take: 5,
|
|
},
|
|
},
|
|
orderBy: { createdAt: 'asc' },
|
|
});
|
|
|
|
res.json({ success: true, data: meters } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({ success: false, error: 'Fehler beim Laden der Zähler' } as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function markReadingTransferred(req: AuthRequest, res: Response): Promise<void> {
|
|
try {
|
|
const meterId = parseInt(req.params.meterId);
|
|
const readingId = parseInt(req.params.readingId);
|
|
|
|
const reading = await prisma.meterReading.update({
|
|
where: { id: readingId },
|
|
data: {
|
|
status: 'TRANSFERRED',
|
|
transferredAt: new Date(),
|
|
transferredBy: req.user?.email,
|
|
},
|
|
});
|
|
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'MeterReading',
|
|
resourceId: readingId.toString(),
|
|
label: `Zählerstand als übertragen markiert`,
|
|
});
|
|
|
|
res.json({ success: true, data: reading } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
// ==================== PORTAL SETTINGS ====================
|
|
|
|
export async function getPortalSettings(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const settings = await customerService.getPortalSettings(parseInt(req.params.customerId));
|
|
if (!settings) {
|
|
res.status(404).json({ success: false, error: 'Kunde nicht gefunden' } as ApiResponse);
|
|
return;
|
|
}
|
|
// Passwort-Hash nicht zurückgeben, nur ob ein Passwort gesetzt ist
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
id: settings.id,
|
|
portalEnabled: settings.portalEnabled,
|
|
portalEmail: settings.portalEmail,
|
|
portalLastLogin: settings.portalLastLogin,
|
|
hasPassword: !!settings.portalPasswordHash,
|
|
},
|
|
} as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Fehler beim Laden der Portal-Einstellungen',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function updatePortalSettings(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.customerId);
|
|
const { portalEnabled, portalEmail } = req.body;
|
|
|
|
// Vorherigen Stand laden für Audit
|
|
const before = await prisma.customer.findUnique({
|
|
where: { id: customerId },
|
|
select: { portalEnabled: true, portalEmail: true },
|
|
});
|
|
|
|
const settings = await customerService.updatePortalSettings(customerId, {
|
|
portalEnabled,
|
|
portalEmail,
|
|
});
|
|
|
|
// Audit: Geänderte Felder ermitteln und loggen
|
|
const data: Record<string, unknown> = { portalEnabled, portalEmail };
|
|
if (before) {
|
|
const changes: Record<string, { von: unknown; nach: unknown }> = {};
|
|
const fieldLabels: Record<string, string> = {
|
|
portalEnabled: 'Portal aktiv', portalEmail: 'Portal-E-Mail',
|
|
};
|
|
for (const [key, newVal] of Object.entries(data)) {
|
|
if (newVal === undefined) continue;
|
|
const oldVal = (before as any)[key];
|
|
const norm = (v: unknown) => (v === null || v === undefined || v === '' ? null : v);
|
|
if (JSON.stringify(norm(oldVal)) !== JSON.stringify(norm(newVal))) {
|
|
const label = fieldLabels[key] || key;
|
|
const formatVal = (v: unknown) => {
|
|
if (v === null || v === undefined || v === '') return '-';
|
|
if (typeof v === 'boolean') return v ? 'Ja' : 'Nein';
|
|
return String(v);
|
|
};
|
|
changes[label] = { von: formatVal(oldVal), nach: formatVal(newVal) };
|
|
}
|
|
}
|
|
const changeList = Object.entries(changes).map(([f, c]) => `${f}: ${c.von} → ${c.nach}`).join(', ');
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'PortalSettings',
|
|
resourceId: customerId.toString(),
|
|
label: changeList ? `Portal-Einstellungen aktualisiert für Kunde #${customerId}: ${changeList}` : `Portal-Einstellungen aktualisiert für Kunde #${customerId}`,
|
|
details: Object.keys(changes).length > 0 ? changes : undefined,
|
|
customerId,
|
|
});
|
|
} else {
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'PortalSettings',
|
|
resourceId: customerId.toString(),
|
|
label: `Portal-Einstellungen aktualisiert für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
}
|
|
|
|
res.json({ success: true, data: settings } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Aktualisieren der Portal-Einstellungen',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function setPortalPassword(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const { password } = req.body;
|
|
if (!password || password.length < 6) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: 'Passwort muss mindestens 6 Zeichen lang sein',
|
|
} as ApiResponse);
|
|
return;
|
|
}
|
|
const customerId = parseInt(req.params.customerId);
|
|
await authService.setCustomerPortalPassword(customerId, password);
|
|
await logChange({
|
|
req, action: 'UPDATE', resourceType: 'PortalSettings',
|
|
resourceId: customerId.toString(),
|
|
label: `Portal-Passwort gesetzt für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
res.json({ success: true, message: 'Passwort gesetzt' } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Setzen des Passworts',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function getPortalPassword(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const password = await authService.getCustomerPortalPassword(parseInt(req.params.customerId));
|
|
res.json({ success: true, data: { password } } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Fehler beim Abrufen des Passworts',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
// ==================== REPRESENTATIVE MANAGEMENT ====================
|
|
|
|
export async function getRepresentatives(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
// Wer kann diesen Kunden vertreten (representedBy)?
|
|
const representedBy = await customerService.getRepresentedByList(parseInt(req.params.customerId));
|
|
res.json({ success: true, data: representedBy } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Fehler beim Laden der Vertreter',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function addRepresentative(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.customerId);
|
|
const { representativeId, notes } = req.body;
|
|
const representative = await customerService.addRepresentative(
|
|
customerId,
|
|
parseInt(representativeId),
|
|
notes
|
|
);
|
|
await logChange({
|
|
req, action: 'CREATE', resourceType: 'Representative',
|
|
resourceId: representative.id.toString(),
|
|
label: `Vertreter hinzugefügt für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
res.status(201).json({ success: true, data: representative } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Hinzufügen des Vertreters',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function removeRepresentative(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const customerId = parseInt(req.params.customerId);
|
|
await customerService.removeRepresentative(
|
|
customerId,
|
|
parseInt(req.params.representativeId)
|
|
);
|
|
await logChange({
|
|
req, action: 'DELETE', resourceType: 'Representative',
|
|
label: `Vertreter entfernt für Kunde #${customerId}`,
|
|
customerId,
|
|
});
|
|
res.json({ success: true, message: 'Vertreter entfernt' } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : 'Fehler beim Entfernen des Vertreters',
|
|
} as ApiResponse);
|
|
}
|
|
}
|
|
|
|
export async function searchForRepresentative(req: Request, res: Response): Promise<void> {
|
|
try {
|
|
const { search } = req.query;
|
|
if (!search || typeof search !== 'string' || search.length < 2) {
|
|
res.json({ success: true, data: [] } as ApiResponse);
|
|
return;
|
|
}
|
|
const customers = await customerService.searchCustomersForRepresentative(
|
|
search,
|
|
parseInt(req.params.customerId)
|
|
);
|
|
res.json({ success: true, data: customers } as ApiResponse);
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Fehler bei der Suche',
|
|
} as ApiResponse);
|
|
}
|
|
}
|