gitea
4b6138f049
Four related backend features. They are committed together because they interleave in api/views.py and api/serializers.py - one hunk holds the combinations ViewSet, the licensing helpers and LicenseView - and splitting by hunk would produce commits that do not import. ExtraCombination records previously-used combinations of lookup nomenclature values so an operator can refill the Additional Data fields in one click. Deduplicated by a canonical order-independent hash, since JSONField equality compares serialized text on SQLite and so depends on key order. Weighing replaces set_tare/set_gross with a single measure action that assigns by weight - lighter becomes tare, heavier gross - because trucks arrive both loaded and empty. A second, lighter reading moves the first to gross carrying its own timestamp, user and manual fields, so provenance follows the value rather than the slot. Manual entries record who, when and why, gated on the previously unenforced can_measure and can_manually_measure flags. ScaleProtocol stores how to read each indicator, so a new scale type is a configuration change rather than a new binary on every station PC. Licensing is offline and node-locked: the server verifies an Ed25519 signature against a fingerprint of four hardware components, tolerating one change, and counts concurrently connected stations. Sites are air-gapped, so there is no activation server. A 14-day grace period keeps an unlicensed or newly-invalid install working, because a licence check must never stop a weighbridge without warning. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
404 lines
16 KiB
Python
404 lines
16 KiB
Python
from rest_framework import serializers
|
|
from django.contrib.auth.password_validation import validate_password
|
|
from .models import ComPortReading, User, Report, ScaleProtocol
|
|
from vehicles.models import Vehicle, VehicleExtra, ExtraCombination
|
|
from nomenclatures.models import Nomenclature, NomenclatureField, NomenclatureEntry
|
|
|
|
|
|
class UserSerializer(serializers.ModelSerializer):
|
|
password = serializers.CharField(write_only=True, required=False)
|
|
|
|
class Meta:
|
|
model = User
|
|
fields = ['id', 'username', 'email', 'first_name', 'last_name',
|
|
'role', 'is_admin', 'is_active', 'date_joined', 'password',
|
|
'can_measure', 'can_manually_measure', 'can_manage_entities', 'can_edit_documents']
|
|
read_only_fields = ['id', 'date_joined']
|
|
extra_kwargs = {
|
|
'password': {'write_only': True}
|
|
}
|
|
|
|
def create(self, validated_data):
|
|
password = validated_data.pop('password', None)
|
|
user = User(**validated_data)
|
|
if password:
|
|
user.set_password(password)
|
|
user.save()
|
|
return user
|
|
|
|
def update(self, instance, validated_data):
|
|
password = validated_data.pop('password', None)
|
|
for attr, value in validated_data.items():
|
|
setattr(instance, attr, value)
|
|
if password:
|
|
instance.set_password(password)
|
|
instance.save()
|
|
return instance
|
|
|
|
|
|
class UserDetailSerializer(serializers.ModelSerializer):
|
|
"""Serializer for current user details (excludes password)"""
|
|
class Meta:
|
|
model = User
|
|
fields = ['id', 'username', 'email', 'first_name', 'last_name',
|
|
'role', 'is_admin', 'is_active', 'date_joined',
|
|
'can_measure', 'can_manually_measure', 'can_manage_entities', 'can_edit_documents']
|
|
read_only_fields = ['id', 'date_joined']
|
|
|
|
|
|
class ChangePasswordSerializer(serializers.Serializer):
|
|
"""Serializer for password change endpoint"""
|
|
old_password = serializers.CharField(required=True, write_only=True)
|
|
new_password = serializers.CharField(required=True, write_only=True)
|
|
|
|
def validate_old_password(self, value):
|
|
user = self.context['request'].user
|
|
if not user.check_password(value):
|
|
raise serializers.ValidationError("Old password is incorrect")
|
|
return value
|
|
|
|
def validate_new_password(self, value):
|
|
# Use Django's password validators
|
|
validate_password(value, self.context['request'].user)
|
|
return value
|
|
|
|
def save(self, **kwargs):
|
|
user = self.context['request'].user
|
|
user.set_password(self.validated_data['new_password'])
|
|
user.save()
|
|
return user
|
|
|
|
|
|
class ComPortReadingSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = ComPortReading
|
|
fields = ['id', 'port', 'data', 'timestamp', 'source_ip']
|
|
read_only_fields = ['id', 'timestamp']
|
|
|
|
|
|
def validate_vehicle_extra_data(value, lookup_only=False):
|
|
"""Validate a {nomenclature_code: value} dict against vehicle nomenclatures.
|
|
|
|
lookup_only=True rejects any key whose nomenclature is not kind='lookup'.
|
|
"""
|
|
if not value:
|
|
return value
|
|
|
|
nomenclatures = {
|
|
n.code: n for n in
|
|
Nomenclature.objects.filter(applies_to='vehicle').prefetch_related('fields', 'entries')
|
|
}
|
|
|
|
errors = {}
|
|
for key, val in value.items():
|
|
if key not in nomenclatures:
|
|
errors[key] = f"Unknown nomenclature code '{key}'."
|
|
continue
|
|
|
|
nom = nomenclatures[key]
|
|
|
|
if nom.kind == Nomenclature.LOOKUP:
|
|
if not isinstance(val, int):
|
|
errors[key] = "Must be a nomenclature entry ID (integer)."
|
|
elif not nom.entries.filter(id=val, is_active=True).exists():
|
|
errors[key] = f"Entry ID {val} not found in '{nom.code}'."
|
|
|
|
elif nom.kind == Nomenclature.FIELD:
|
|
if lookup_only:
|
|
errors[key] = "Only lookup nomenclatures are allowed here."
|
|
continue
|
|
field_def = nom.fields.first()
|
|
if field_def:
|
|
if field_def.field_type == NomenclatureField.TEXT and not isinstance(val, str):
|
|
errors[key] = "Must be a string."
|
|
elif field_def.field_type == NomenclatureField.NUMBER and not isinstance(val, (int, float)):
|
|
errors[key] = "Must be a number."
|
|
elif field_def.field_type == NomenclatureField.BOOL and not isinstance(val, bool):
|
|
errors[key] = "Must be a boolean."
|
|
elif field_def.field_type == NomenclatureField.CHOICE and val not in (field_def.choices or []):
|
|
errors[key] = f"Must be one of {field_def.choices}."
|
|
|
|
if errors:
|
|
raise serializers.ValidationError(errors)
|
|
|
|
return value
|
|
|
|
|
|
class VehicleExtraSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = VehicleExtra
|
|
fields = ['id', 'data']
|
|
read_only_fields = ['id']
|
|
|
|
def validate_data(self, value):
|
|
return validate_vehicle_extra_data(value)
|
|
|
|
|
|
class VehicleSerializer(serializers.ModelSerializer):
|
|
extra = VehicleExtraSerializer(required=False, allow_null=True)
|
|
tare_user_name = serializers.CharField(source='tare_user.username', read_only=True, default=None)
|
|
gross_user_name = serializers.CharField(source='gross_user.username', read_only=True, default=None)
|
|
net_user_name = serializers.CharField(source='net_user.username', read_only=True, default=None)
|
|
|
|
class Meta:
|
|
model = Vehicle
|
|
fields = ['id', 'vehicle_number', 'trailer1_number', 'trailer2_number', 'driver_pid',
|
|
'tare', 'tare_date', 'tare_user', 'tare_user_name',
|
|
'tare_manual', 'tare_manual_user', 'tare_manual_date', 'tare_manual_note',
|
|
'gross', 'gross_date', 'gross_user', 'gross_user_name',
|
|
'gross_manual', 'gross_manual_user', 'gross_manual_date', 'gross_manual_note',
|
|
'net', 'net_date', 'net_user', 'net_user_name',
|
|
'doc_number', 'extra']
|
|
read_only_fields = ['id', 'tare_date', 'tare_user', 'tare_user_name',
|
|
'tare_manual', 'tare_manual_user', 'tare_manual_date', 'tare_manual_note',
|
|
'gross_date', 'gross_user', 'gross_user_name',
|
|
'gross_manual', 'gross_manual_user', 'gross_manual_date', 'gross_manual_note',
|
|
'net', 'net_date', 'net_user', 'net_user_name',
|
|
'doc_number']
|
|
|
|
def create(self, validated_data):
|
|
extra_data = validated_data.pop('extra', None)
|
|
vehicle = Vehicle.objects.create(**validated_data)
|
|
|
|
if extra_data:
|
|
VehicleExtra.objects.create(vehicle=vehicle, **extra_data)
|
|
|
|
return vehicle
|
|
|
|
def update(self, instance, validated_data):
|
|
extra_data = validated_data.pop('extra', None)
|
|
|
|
for attr, value in validated_data.items():
|
|
setattr(instance, attr, value)
|
|
instance.save()
|
|
|
|
# Handle VehicleExtra update/creation
|
|
if extra_data is not None:
|
|
if hasattr(instance, 'extra'):
|
|
for attr, value in extra_data.items():
|
|
setattr(instance.extra, attr, value)
|
|
instance.extra.save()
|
|
else:
|
|
VehicleExtra.objects.create(vehicle=instance, **extra_data)
|
|
|
|
return instance
|
|
|
|
def validate_vehicle_number(self, value):
|
|
if not value or not value.strip():
|
|
raise serializers.ValidationError("Vehicle number cannot be empty")
|
|
return value.strip()
|
|
|
|
|
|
class ExtraCombinationSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = ExtraCombination
|
|
fields = ['id', 'data', 'use_count', 'last_used']
|
|
read_only_fields = ['id', 'use_count', 'last_used']
|
|
|
|
def validate_data(self, value):
|
|
if not value:
|
|
raise serializers.ValidationError("Combination cannot be empty.")
|
|
return validate_vehicle_extra_data(value, lookup_only=True)
|
|
|
|
|
|
class ScaleProtocolSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = ScaleProtocol
|
|
fields = ['id', 'name', 'kind', 'poll_command', 'poll_interval',
|
|
'config', 'is_builtin', 'is_active']
|
|
read_only_fields = ['id', 'is_builtin']
|
|
|
|
def validate_poll_interval(self, value):
|
|
if value <= 0:
|
|
raise serializers.ValidationError("Poll interval must be greater than zero.")
|
|
return value
|
|
|
|
def validate(self, attrs):
|
|
kind = attrs.get('kind', getattr(self.instance, 'kind', None))
|
|
config = attrs.get('config', getattr(self.instance, 'config', None) or {})
|
|
|
|
if kind == ScaleProtocol.FIXED_COLUMN:
|
|
# A misconfigured offset silently clips a digit off every weight, so
|
|
# reject anything unusable rather than storing it.
|
|
errors = {}
|
|
for key in ('weight_start', 'weight_length', 'stable_pos'):
|
|
value = config.get(key)
|
|
if not isinstance(value, int) or isinstance(value, bool) or value < 0:
|
|
errors[key] = "Must be a non-negative integer."
|
|
if not isinstance(config.get('weight_length'), bool) and isinstance(config.get('weight_length'), int) and config['weight_length'] < 1:
|
|
errors['weight_length'] = "Must be at least 1."
|
|
stable_char = config.get('stable_char', ' ')
|
|
if not isinstance(stable_char, str) or len(stable_char) != 1:
|
|
errors['stable_char'] = "Must be exactly one character."
|
|
if errors:
|
|
raise serializers.ValidationError({'config': errors})
|
|
|
|
return attrs
|
|
|
|
|
|
class NomenclatureFieldSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = NomenclatureField
|
|
fields = ['id', 'key', 'label', 'field_type', 'required', 'choices', 'sort_order']
|
|
read_only_fields = ['id']
|
|
|
|
def validate_key(self, value):
|
|
if not value or not value.strip():
|
|
raise serializers.ValidationError("Field key cannot be empty")
|
|
return value.strip()
|
|
|
|
def validate_field_type(self, value):
|
|
valid_types = [choice[0] for choice in NomenclatureField.FIELD_TYPES]
|
|
if value not in valid_types:
|
|
raise serializers.ValidationError(
|
|
f"Invalid field type. Must be one of: {', '.join(valid_types)}"
|
|
)
|
|
return value
|
|
|
|
def validate(self, data):
|
|
if data.get('field_type') == NomenclatureField.CHOICE:
|
|
choices = data.get('choices')
|
|
if not choices or not isinstance(choices, list) or len(choices) == 0:
|
|
raise serializers.ValidationError({
|
|
'choices': 'Choices must be a non-empty list for choice fields.'
|
|
})
|
|
elif data.get('choices'):
|
|
raise serializers.ValidationError({
|
|
'choices': 'Only choice-type fields can have choices.'
|
|
})
|
|
return data
|
|
|
|
|
|
class NomenclatureEntrySerializer(serializers.ModelSerializer):
|
|
display_value = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = NomenclatureEntry
|
|
fields = ['id', 'data', 'is_active', 'display_value']
|
|
read_only_fields = ['id']
|
|
|
|
def get_display_value(self, obj):
|
|
display_key = obj.nomenclature.display_field or "name"
|
|
return obj.data.get(display_key, f"Entry #{obj.pk}")
|
|
|
|
def validate_data(self, value):
|
|
nomenclature = self.context.get('nomenclature')
|
|
if not nomenclature:
|
|
return value
|
|
|
|
field_defs = {f.key: f for f in nomenclature.fields.all()}
|
|
|
|
for key in value.keys():
|
|
if key not in field_defs:
|
|
raise serializers.ValidationError(
|
|
f"Unknown field '{key}'. Valid fields: {list(field_defs.keys())}"
|
|
)
|
|
|
|
for key, field_def in field_defs.items():
|
|
if field_def.required and key not in value:
|
|
raise serializers.ValidationError(
|
|
f"Required field '{key}' is missing."
|
|
)
|
|
|
|
for key, val in value.items():
|
|
if key not in field_defs:
|
|
continue
|
|
field_def = field_defs[key]
|
|
|
|
if field_def.field_type == NomenclatureField.TEXT and not isinstance(val, str):
|
|
raise serializers.ValidationError(f"Field '{key}' must be a string.")
|
|
elif field_def.field_type == NomenclatureField.NUMBER and not isinstance(val, (int, float)):
|
|
raise serializers.ValidationError(f"Field '{key}' must be a number.")
|
|
elif field_def.field_type == NomenclatureField.BOOL and not isinstance(val, bool):
|
|
raise serializers.ValidationError(f"Field '{key}' must be a boolean.")
|
|
elif field_def.field_type == NomenclatureField.CHOICE and val not in (field_def.choices or []):
|
|
raise serializers.ValidationError(f"Field '{key}' must be one of {field_def.choices}.")
|
|
|
|
return value
|
|
|
|
|
|
class NomenclatureSerializer(serializers.ModelSerializer):
|
|
fields = NomenclatureFieldSerializer(many=True, required=False)
|
|
entry_count = serializers.IntegerField(source='entries.count', read_only=True)
|
|
|
|
class Meta:
|
|
model = Nomenclature
|
|
fields = ['id', 'code', 'name', 'applies_to', 'kind', 'display_field',
|
|
'sort_order', 'fields', 'entry_count']
|
|
read_only_fields = ['id']
|
|
|
|
def create(self, validated_data):
|
|
fields_data = validated_data.pop('fields', [])
|
|
nomenclature = Nomenclature.objects.create(**validated_data)
|
|
|
|
for field_data in fields_data:
|
|
NomenclatureField.objects.create(nomenclature=nomenclature, **field_data)
|
|
|
|
return nomenclature
|
|
|
|
def update(self, instance, validated_data):
|
|
fields_data = validated_data.pop('fields', None)
|
|
|
|
for attr, value in validated_data.items():
|
|
setattr(instance, attr, value)
|
|
instance.save()
|
|
|
|
if fields_data is not None:
|
|
instance.fields.all().delete()
|
|
for field_data in fields_data:
|
|
NomenclatureField.objects.create(nomenclature=instance, **field_data)
|
|
|
|
return instance
|
|
|
|
def validate_code(self, value):
|
|
if not value or not value.strip():
|
|
raise serializers.ValidationError("Code cannot be empty")
|
|
return value.strip()
|
|
|
|
def validate_applies_to(self, value):
|
|
valid_choices = ['vehicle', 'container']
|
|
if value not in valid_choices:
|
|
raise serializers.ValidationError(
|
|
f"Invalid applies_to value. Must be one of: {', '.join(valid_choices)}"
|
|
)
|
|
return value
|
|
|
|
def validate(self, data):
|
|
kind = data.get('kind', getattr(self.instance, 'kind', Nomenclature.LOOKUP))
|
|
fields_data = data.get('fields', [])
|
|
|
|
if kind == Nomenclature.FIELD and fields_data and len(fields_data) != 1:
|
|
raise serializers.ValidationError(
|
|
"A 'field' nomenclature must have exactly one field definition."
|
|
)
|
|
|
|
if kind == Nomenclature.LOOKUP:
|
|
display_field = data.get('display_field', getattr(self.instance, 'display_field', 'name'))
|
|
field_keys = [f['key'] for f in fields_data] if fields_data else []
|
|
if field_keys and display_field not in field_keys:
|
|
raise serializers.ValidationError(
|
|
f"display_field '{display_field}' must match one of the defined field keys."
|
|
)
|
|
|
|
return data
|
|
|
|
|
|
class ReportSerializer(serializers.ModelSerializer):
|
|
created_by_name = serializers.CharField(source='created_by.username', read_only=True, default=None)
|
|
|
|
class Meta:
|
|
model = Report
|
|
fields = ['id', 'name', 'page_width', 'page_height', 'api_endpoint',
|
|
'elements', 'created_by', 'created_by_name', 'created_at', 'updated_at']
|
|
read_only_fields = ['id', 'created_by', 'created_by_name', 'created_at', 'updated_at']
|
|
|
|
def validate_name(self, value):
|
|
if not value or not value.strip():
|
|
raise serializers.ValidationError("Report name cannot be empty")
|
|
return value.strip()
|
|
|
|
def validate_elements(self, value):
|
|
if not isinstance(value, list):
|
|
raise serializers.ValidationError("Elements must be a list")
|
|
return value
|