314 lines
15 KiB
Python
314 lines
15 KiB
Python
from django import forms
|
|
from copy import deepcopy
|
|
from django.db import models
|
|
from django.contrib.auth.models import User
|
|
from django.contrib.auth.password_validation import validate_password
|
|
|
|
from .models import ChoiceValue, Device, Employee, FieldDefinition, FieldOption, UserProfile
|
|
from .device_types import HARDWARE_FIELDS, applicable_fields
|
|
|
|
|
|
GERMAN_DATE_INPUT_FORMATS = ["%d.%m.%Y", "%Y-%m-%d"]
|
|
GERMAN_DATE_WIDGET = {"type": "text", "placeholder": "TT.MM.JJJJ", "inputmode": "numeric", "data-german-date": ""}
|
|
STATUS_COLOR_CHOICES = [
|
|
("#2563eb", "Blau"), ("#0891b2", "Türkis"), ("#15803d", "Grün"),
|
|
("#4d7c0f", "Limette"), ("#b45309", "Orange"), ("#a16207", "Gelb"),
|
|
("#dc2626", "Rot"), ("#be185d", "Pink"), ("#7c3aed", "Violett"),
|
|
("#4f46e5", "Indigo"), ("#64748b", "Grau"), ("#334155", "Anthrazit"),
|
|
]
|
|
|
|
|
|
class QuickAddForm(forms.Form):
|
|
number = forms.IntegerField(label="Erste Nr.", min_value=1, max_value=2147483647, help_text="Die vorgeschlagene Startnummer kann geändert werden.")
|
|
quantity = forms.IntegerField(label="Anzahl", min_value=1, initial=1, help_text="Alle Geräte erhalten aufsteigende Nummern.")
|
|
shelf = forms.CharField(label="Regal", max_length=80, required=False)
|
|
status = forms.ModelChoiceField(label="Status", queryset=ChoiceValue.objects.none())
|
|
date = forms.DateField(
|
|
label="Datum", input_formats=GERMAN_DATE_INPUT_FORMATS,
|
|
widget=forms.DateInput(format="%d.%m.%Y", attrs=GERMAN_DATE_WIDGET),
|
|
)
|
|
device_type = forms.ModelChoiceField(label="Typ", queryset=ChoiceValue.objects.none(), required=False)
|
|
employee = forms.ModelChoiceField(
|
|
label="Bearbeiter", queryset=Employee.objects.none(), required=True,
|
|
empty_label="Bearbeiter auswählen", error_messages={"required": "Bitte einen Bearbeiter auswählen."},
|
|
)
|
|
donor = forms.CharField(label="Spender", max_length=200, required=False)
|
|
model = forms.CharField(label="Modell", max_length=200, required=False)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.fields["status"].queryset = ChoiceValue.objects.filter(kind=ChoiceValue.Kind.STATUS, active=True)
|
|
self.fields["device_type"].queryset = ChoiceValue.objects.filter(kind=ChoiceValue.Kind.DEVICE_TYPE, active=True)
|
|
self.fields["employee"].queryset = Employee.objects.filter(active=True)
|
|
selected_type = None
|
|
if self.is_bound and str(self.data.get("device_type", "")).isdecimal():
|
|
selected_type = self.fields["device_type"].queryset.filter(pk=self.data["device_type"]).first()
|
|
for name in sorted(HARDWARE_FIELDS):
|
|
field = deepcopy(DeviceForm.base_fields[name])
|
|
if name in {"battery", "wifi", "lan", "duplex", "color_printing"}:
|
|
field.required = False
|
|
field.initial = Device.TriState.UNKNOWN
|
|
if self.is_bound and name not in applicable_fields(selected_type):
|
|
field.disabled = True
|
|
self.fields[name] = field
|
|
|
|
@property
|
|
def hardware_fields(self):
|
|
return [self[name] for name in self.fields if name in HARDWARE_FIELDS]
|
|
|
|
def selected_hardware_values(self):
|
|
values = {}
|
|
for name in applicable_fields(self.cleaned_data["device_type"]):
|
|
value = self.cleaned_data[name]
|
|
if name in {"battery", "wifi", "lan", "duplex", "color_printing"} and not value:
|
|
value = Device.TriState.UNKNOWN
|
|
values[name] = value
|
|
return values
|
|
|
|
def clean_number(self):
|
|
number = self.cleaned_data["number"]
|
|
if Device.objects.filter(number=number).exists():
|
|
raise forms.ValidationError(f"Die Gerätenummer {number} ist bereits vergeben.")
|
|
return number
|
|
|
|
def clean(self):
|
|
cleaned = super().clean()
|
|
first_number = cleaned.get("number")
|
|
quantity = cleaned.get("quantity")
|
|
if first_number is None or quantity is None:
|
|
return cleaned
|
|
last_number = first_number + quantity - 1
|
|
if last_number > 2147483647:
|
|
self.add_error("quantity", "Die letzte Gerätenummer wäre zu groß.")
|
|
return cleaned
|
|
conflict = Device.objects.filter(number__range=(first_number, last_number)).order_by("number").values_list("number", flat=True).first()
|
|
if conflict is not None:
|
|
self.add_error("number", f"Die Gerätenummer {conflict} ist bereits vergeben.")
|
|
return cleaned
|
|
|
|
|
|
class DeviceForm(forms.ModelForm):
|
|
battery = forms.ChoiceField(label="Akku", choices=Device.TriState.choices, required=False)
|
|
wifi = forms.ChoiceField(label="WLAN", choices=Device.TriState.choices, required=False)
|
|
lan = forms.ChoiceField(label="LAN", choices=Device.TriState.choices, required=False)
|
|
display_inches = forms.DecimalField(label="Zoll", max_digits=4, decimal_places=1, min_value=0, required=False, widget=forms.NumberInput(attrs={"step": "0.1"}))
|
|
ram_gb = forms.IntegerField(label="RAM (GB)", min_value=0, required=False)
|
|
ssd_gb = forms.IntegerField(label="SSD (GB)", min_value=0, required=False)
|
|
hdd_gb = forms.IntegerField(label="HDD (GB)", min_value=0, required=False)
|
|
cpu = forms.CharField(label="Prozessor", max_length=200, required=False)
|
|
hwid = forms.CharField(label="HWID", max_length=255, required=False)
|
|
ports = forms.CharField(label="Anschlüsse", max_length=255, required=False)
|
|
resolution = forms.CharField(label="Auflösung", max_length=80, required=False)
|
|
print_technology = forms.CharField(label="Druckverfahren", max_length=80, required=False)
|
|
duplex = forms.ChoiceField(label="Duplex", choices=Device.TriState.choices, required=False)
|
|
color_printing = forms.ChoiceField(label="Farbdruck", choices=Device.TriState.choices, required=False)
|
|
|
|
class Meta:
|
|
model = Device
|
|
exclude = ["number", "archived_at", "archived_by", "custom_values", "stage"]
|
|
labels = {
|
|
"shelf": "Regal", "status": "Bestandsstatus", "date": "Datum", "recipient": "Empfänger",
|
|
"location": "Ort", "ticket": "Ticket", "device_type": "Typ", "price": "Preis",
|
|
"battery": "Akku", "wifi": "WLAN", "lan": "LAN", "display_inches": "Zoll",
|
|
"ram_gb": "RAM (GB)", "ssd_gb": "SSD (GB)", "hdd_gb": "HDD (GB)",
|
|
"cpu": "Prozessor", "hwid": "HWID", "model": "Modell", "employee": "Bearbeiter",
|
|
"donor": "Spender", "comment": "Kommentar",
|
|
}
|
|
widgets = {
|
|
"date": forms.DateInput(format="%d.%m.%Y", attrs=GERMAN_DATE_WIDGET),
|
|
"comment": forms.Textarea(attrs={"rows": 4}),
|
|
"price": forms.NumberInput(attrs={"step": "0.01"}),
|
|
"display_inches": forms.NumberInput(attrs={"step": "0.1"}),
|
|
}
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
if not self.is_bound:
|
|
for name in HARDWARE_FIELDS:
|
|
self.initial.setdefault(name, getattr(self.instance, name))
|
|
selected_type = self.instance.device_type if self.instance.device_type_id else None
|
|
if self.is_bound and str(self.data.get("device_type", "")).isdecimal():
|
|
selected_type = ChoiceValue.objects.filter(
|
|
pk=self.data.get("device_type"), kind=ChoiceValue.Kind.DEVICE_TYPE,
|
|
).first()
|
|
if self.is_bound:
|
|
for name in HARDWARE_FIELDS - applicable_fields(selected_type):
|
|
self.fields[name].disabled = True
|
|
self.fields["date"].input_formats = GERMAN_DATE_INPUT_FORMATS
|
|
mapping = {
|
|
"status": ChoiceValue.Kind.STATUS,
|
|
"recipient": ChoiceValue.Kind.RECIPIENT,
|
|
"location": ChoiceValue.Kind.LOCATION,
|
|
"device_type": ChoiceValue.Kind.DEVICE_TYPE,
|
|
}
|
|
for field_name, kind in mapping.items():
|
|
current = getattr(self.instance, f"{field_name}_id", None)
|
|
queryset = ChoiceValue.objects.filter(kind=kind, active=True)
|
|
if current:
|
|
queryset = ChoiceValue.objects.filter(kind=kind).filter(models.Q(active=True) | models.Q(pk=current))
|
|
self.fields[field_name].queryset = queryset
|
|
current_employee = getattr(self.instance, "employee_id", None)
|
|
employee_queryset = Employee.objects.filter(active=True)
|
|
if current_employee:
|
|
employee_queryset = Employee.objects.filter(models.Q(active=True) | models.Q(pk=current_employee))
|
|
self.fields["employee"].queryset = employee_queryset
|
|
for field_name in ["ram_gb", "ssd_gb", "hdd_gb", "display_inches"]:
|
|
if field_name in self.fields:
|
|
self.fields[field_name].widget.attrs["list"] = f"suggestions-{field_name}"
|
|
if "cpu" in self.fields:
|
|
self.fields["cpu"].widget.attrs.update({"data-cpu-autocomplete": "", "autocomplete": "off"})
|
|
|
|
def save(self, commit=True):
|
|
device = super().save(commit=False)
|
|
for name in applicable_fields(device.device_type):
|
|
value = self.cleaned_data[name]
|
|
if name in {"battery", "wifi", "lan", "duplex", "color_printing"} and not value:
|
|
value = Device.TriState.UNKNOWN
|
|
setattr(device, name, value)
|
|
if commit:
|
|
device.save()
|
|
self.save_m2m()
|
|
return device
|
|
|
|
|
|
class InspectionForm(forms.Form):
|
|
defects = forms.CharField(label="Festgestellte Mängel", widget=forms.Textarea(attrs={"rows": 2}), max_length=4000)
|
|
model = forms.CharField(label="Modell", max_length=200, required=False)
|
|
|
|
def __init__(self, *args, device, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.device = device
|
|
self.initial.setdefault("model", device.model)
|
|
for name in ("cpu", "ram_gb", "ssd_gb", "hdd_gb", "display_inches", "battery", "wifi", "lan", "hwid", "ports", "resolution", "print_technology", "duplex", "color_printing"):
|
|
if name in applicable_fields(device.device_type):
|
|
self.fields[name] = deepcopy(DeviceForm.base_fields[name])
|
|
self.initial.setdefault(name, getattr(device, name))
|
|
|
|
@property
|
|
def specification_fields(self):
|
|
return [self[name] for name in self.fields if name != "defects"]
|
|
|
|
|
|
class RepairForm(forms.Form):
|
|
work_done = forms.CharField(label="Durchgeführte Arbeiten", max_length=4000, widget=forms.Textarea(attrs={"rows": 2}))
|
|
|
|
|
|
class StorageRecipientForm(forms.Form):
|
|
recipient = forms.CharField(label="Empfänger", max_length=120)
|
|
|
|
|
|
class EmployeeForm(forms.ModelForm):
|
|
class Meta:
|
|
model = Employee
|
|
fields = ["code", "name", "active"]
|
|
labels = {"code": "Kürzel", "name": "Name", "active": "Aktiv"}
|
|
help_texts = {"code": "Kurzes eindeutiges Kürzel, zum Beispiel JH."}
|
|
|
|
|
|
class ChoiceValueForm(forms.ModelForm):
|
|
color = forms.ChoiceField(
|
|
label="Farbe", choices=STATUS_COLOR_CHOICES, required=False,
|
|
widget=forms.RadioSelect, help_text="Wird für Statuswerte in Liste und Übersicht verwendet.",
|
|
)
|
|
|
|
class Meta:
|
|
model = ChoiceValue
|
|
fields = ["kind", "label", "color", "numeric_value", "active", "sort_order"]
|
|
labels = {
|
|
"kind": "Kategorie", "label": "Bezeichnung", "numeric_value": "Zahlenwert",
|
|
"active": "Aktiv", "sort_order": "Sortierreihenfolge",
|
|
}
|
|
|
|
def clean(self):
|
|
cleaned = super().clean()
|
|
if cleaned.get("kind") == ChoiceValue.Kind.STATUS and not cleaned.get("color"):
|
|
cleaned["color"] = STATUS_COLOR_CHOICES[0][0]
|
|
return cleaned
|
|
|
|
|
|
class FieldDefinitionForm(forms.ModelForm):
|
|
options_text = forms.CharField(
|
|
required=False, label="Optionen", help_text="Eine Option pro Zeile (nur für Auswahlfelder).",
|
|
widget=forms.Textarea(attrs={"rows": 5}),
|
|
)
|
|
|
|
class Meta:
|
|
model = FieldDefinition
|
|
fields = [
|
|
"name", "key", "field_type", "unit", "required", "active", "show_in_list",
|
|
"filterable", "searchable", "sort_order", "group", "allow_custom_values",
|
|
]
|
|
labels = {
|
|
"name": "Name", "key": "Interner Schlüssel", "field_type": "Feldtyp", "unit": "Einheit",
|
|
"required": "Pflichtfeld", "active": "Aktiv", "show_in_list": "In der Geräteliste anzeigen",
|
|
"filterable": "Filterbar", "searchable": "Durchsuchbar", "sort_order": "Sortierreihenfolge",
|
|
"group": "Gruppe", "allow_custom_values": "Eigene Werte erlauben",
|
|
}
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
if self.instance.pk:
|
|
self.fields["options_text"].initial = "\n".join(self.instance.options.values_list("label", flat=True))
|
|
self.fields["key"].disabled = True
|
|
self.fields["key"].help_text = "Der interne Key bleibt nach dem Anlegen stabil."
|
|
|
|
def save(self, commit=True):
|
|
instance = super().save(commit=commit)
|
|
if commit:
|
|
labels = [line.strip() for line in self.cleaned_data.get("options_text", "").splitlines() if line.strip()]
|
|
for order, label in enumerate(labels):
|
|
FieldOption.objects.update_or_create(field=instance, label=label, defaults={"sort_order": order, "active": True})
|
|
instance.options.exclude(label__in=labels).update(active=False)
|
|
return instance
|
|
|
|
|
|
class ExcelUploadForm(forms.Form):
|
|
file = forms.FileField(label="Excel-Datei (.xlsx)")
|
|
|
|
def clean_file(self):
|
|
uploaded = self.cleaned_data["file"]
|
|
if not uploaded.name.lower().endswith(".xlsx"):
|
|
raise forms.ValidationError("Bitte eine .xlsx-Datei auswählen.")
|
|
if uploaded.size > 10 * 1024 * 1024:
|
|
raise forms.ValidationError("Die Datei darf höchstens 10 MB groß sein.")
|
|
return uploaded
|
|
|
|
|
|
class UserManagementForm(forms.ModelForm):
|
|
role = forms.ChoiceField(label="Rolle", choices=UserProfile.Role.choices)
|
|
password = forms.CharField(label="Passwort", required=False, widget=forms.PasswordInput, help_text="Bei bestehenden Konten leer lassen, um das Passwort nicht zu ändern.")
|
|
|
|
class Meta:
|
|
model = User
|
|
fields = ["username", "first_name", "last_name", "email", "is_active"]
|
|
labels = {
|
|
"username": "Benutzername", "first_name": "Vorname", "last_name": "Nachname",
|
|
"email": "E-Mail-Adresse", "is_active": "Aktiv",
|
|
}
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
if self.instance.pk:
|
|
profile, _ = UserProfile.objects.get_or_create(user=self.instance)
|
|
self.fields["role"].initial = profile.role
|
|
|
|
def clean_password(self):
|
|
password = self.cleaned_data.get("password", "")
|
|
if not self.instance.pk and not password:
|
|
raise forms.ValidationError("Für ein neues Konto ist ein Passwort erforderlich.")
|
|
if password:
|
|
validate_password(password, self.instance if self.instance.pk else None)
|
|
return password
|
|
|
|
def save(self, commit=True):
|
|
user = super().save(commit=False)
|
|
password = self.cleaned_data.get("password")
|
|
if password:
|
|
user.set_password(password)
|
|
if commit:
|
|
user.save()
|
|
profile, _ = UserProfile.objects.get_or_create(user=user)
|
|
profile.role = UserProfile.Role.ADMIN if user.is_superuser else self.cleaned_data["role"]
|
|
profile.save()
|
|
return user
|