Skip to content

Home Information - Your home, your data, organized.

Python
14.3 KB
Raw Blame
import logging
import re
from typing import Any, Dict, List, Optional

from django.conf import settings
from django.db import transaction
from django.db.models import QuerySet
from django.http import HttpRequest

from hi.constants import DIVID
from hi.testing.dev_overrides import DevOverrideManager

from .forms import AttributeUploadForm
from .edit_context import AttributeItemEditContext
from .enums import AttributeValueType
from .models import AttributeModel
from .transient_models import AttributeEditFormData, AttributeMultiEditFormData

logger = logging.getLogger(__name__)


class AttributeEditFormHandler:

    def create_edit_form_data(
            self,
            attr_item_context  : AttributeItemEditContext,
            form_data          : Optional[ Dict[str, Any] ] = None ) -> AttributeEditFormData:
        """
        Args:
            form_data: POST data for bound forms, None for unbound forms
        """
        owner_form = attr_item_context.create_owner_form( form_data )

        # Get file attributes for display (not a formset, just for template rendering)
        # Display order: manual reorder (order_id ASC) wins; ties
        # break recency-first so newly-uploaded files (default
        # order_id=0) appear at the top of the unsorted block until
        # the operator manually positions them.
        file_attributes: QuerySet[AttributeModel] = attr_item_context.attributes_queryset().filter(
            value_type_str = str( AttributeValueType.FILE )
        ).order_by( 'order_id', '-created_datetime' )

        deleted_attributes = attr_item_context.soft_deleted_attributes_queryset().order_by(
            '-updated_datetime',
            '-id',
        )
        
        # Regular attributes formset (should exclude FILE attributes)
        regular_attributes_formset = attr_item_context.create_regular_attributes_formset(
            form_data = form_data,
        )
        return AttributeEditFormData(
            owner_form = owner_form,
            file_attributes = file_attributes,
            deleted_attributes = deleted_attributes,
            regular_attributes_formset = regular_attributes_formset,
        )

    def validate_forms(self, edit_form_data: AttributeEditFormData) -> bool:
        """
        Returns:
            bool: True if both forms are valid, False otherwise
        """
        if settings.DEBUG and settings.DEBUG_INJECT_ATTRIBUTE_FORM_ERRORS:
            return DevOverrideManager.validate_forms( edit_form_data )
        
        # Normal validation
        if edit_form_data.owner_form and not edit_form_data.owner_form.is_valid():
            return False
        return edit_form_data.regular_attributes_formset.is_valid()
    
    def save_forms( self,
                    attr_item_context   : AttributeItemEditContext,
                    edit_form_data : AttributeEditFormData,
                    request        : HttpRequest ) -> None:

        with transaction.atomic():
            if edit_form_data.owner_form:
                edit_form_data.owner_form.save()
            edit_form_data.regular_attributes_formset.save()
            
            self.process_file_title_updates(
                attr_item_context = attr_item_context,
                request = request,
            )
            self.process_file_order_updates(
                attr_item_context = attr_item_context,
                request = request,
            )
            self.process_file_deletions(
                attr_item_context = attr_item_context,
                request = request,
            )
        return
    
    def process_file_deletions( self,
                                attr_item_context  : AttributeItemEditContext,
                                request       : HttpRequest           ) -> None:
        file_deletes: List[str] = request.POST.getlist( DIVID['ATTR_V2_DELETE_FILE_ATTR'] )
        if not file_deletes:
            return
        
        AttributeModelClass = attr_item_context.attribute_model_subclass
        
        for attr_id in file_deletes:
            if not attr_id:  # Skip empty values
                continue
            try:
                file_attribute = AttributeModelClass.objects.get(
                    id = attr_id,
                    value_type_str = str( AttributeValueType.FILE ),
                )
                # Verify permission to delete
                if file_attribute.attribute_type.can_delete:
                    file_attribute.delete()
            except AttributeModelClass.DoesNotExist:
                pass
            continue
        return
    
    def process_file_title_updates( self,
                                    attr_item_context  : AttributeItemEditContext,
                                    request       : HttpRequest      ) -> None:
        """Process file_title_* fields from POST data to update file attribute values."""
        # Pattern to match file_title_{owner_id}_{attribute_id}
        file_title_pattern = re.compile(r'^file_title_(\d+)_(\d+)$')

        AttributeModelClass = attr_item_context.attribute_model_subclass

        for field_name, new_title in request.POST.items():
            match = file_title_pattern.match(field_name)
            if not match:
                continue
                
            owner_id_str: str
            attribute_id_str: str
            owner_id_str, attribute_id_str = match.groups()
      
            # Validate owner_id matches current owner
            if int(owner_id_str) != attr_item_context.owner.id:
                logger.warning(f'File title field {field_name} has mismatched owner ID')
                continue
            
            try:
                attribute_id: int = int(attribute_id_str)
                attribute = AttributeModelClass.objects.get(
                    id = attribute_id,
                    value_type_str = str( AttributeValueType.FILE ),
                )
                # Clean and validate the new title
                new_title = new_title.strip()
                if not new_title:
                    logger.warning(f'Empty title provided for file attribute {attribute_id}')
                    continue
                
                # Check if title actually changed
                if attribute.value != new_title:
                    attribute.value = new_title
                    attribute.save()  # This will also create a history record
                    
            except (ValueError) as e:
                logger.warning(f'Invalid file title field {field_name}: {e}')
            except (AttributeModelClass.DoesNotExist) as e:
                logger.warning(f'File attribute not found {field_name}: {e}')

    def process_file_order_updates( self,
                                    attr_item_context : AttributeItemEditContext,
                                    request           : HttpRequest      ) -> None:
        """Process file_order_id_* fields from POST data to update
        each file attribute's ``order_id``. File attributes don't
        ride the regular formset, so they need ad-hoc named inputs
        the client populates on reorder.

        The per-row saves run inside one transaction so a mid-batch
        failure can't leave a partially-renumbered ordering. The
        per-row ``ValueError`` / ``DoesNotExist`` paths are
        per-field validation and don't propagate; only unhandled
        exceptions (DB errors) roll back."""
        file_order_pattern = re.compile(r'^file_order_id_(\d+)_(\d+)$')

        AttributeModelClass = attr_item_context.attribute_model_subclass

        with transaction.atomic():
            for field_name, new_order_str in request.POST.items():
                match = file_order_pattern.match(field_name)
                if not match:
                    continue

                owner_id_str: str
                attribute_id_str: str
                owner_id_str, attribute_id_str = match.groups()

                if int(owner_id_str) != attr_item_context.owner.id:
                    logger.warning(
                        f'File order field {field_name} has mismatched owner ID'
                    )
                    continue

                try:
                    attribute_id: int = int(attribute_id_str)
                    new_order: int = int(new_order_str)
                    attribute = AttributeModelClass.objects.get(
                        id = attribute_id,
                        value_type_str = str( AttributeValueType.FILE ),
                    )
                    if attribute.order_id != new_order:
                        attribute.order_id = new_order
                        attribute.save( update_fields = [ 'order_id' ] )
                except (ValueError) as e:
                    logger.warning(
                        f'Invalid file order field {field_name}: {e}'
                    )
                except (AttributeModelClass.DoesNotExist) as e:
                    logger.warning(
                        f'File attribute not found {field_name}: {e}'
                    )

    def collect_form_errors(self, edit_form_data: AttributeEditFormData) -> List[str]:
        """
        Collect errors for central display and count all form errors (as side efffect).

        Note: Individual form.non_field_errors() are NOT collected in the return list
        They should be displayed inline with the specific forms/fields
        """

        non_form_errors = []
        total_error_count = 0
        
        if edit_form_data.owner_form:
            owner_form = edit_form_data.owner_form
            total_error_count += len( owner_form.non_field_errors() )
            for field_name in owner_form.fields:
                total_error_count += len( owner_form[field_name].errors )
                continue
        
        if edit_form_data.regular_attributes_formset:
            formset = edit_form_data.regular_attributes_formset
            try:
                # Accessing management_form will raise ValidationError if data is missing
                formset.management_form
            except Exception:
                # Management form missing - count as one system error
                total_error_count += 1
                non_form_errors.append(
                    "Form data is missing or incomplete."
                )
            else:
                # Count formset-level errors
                formset_non_form_errors = formset.non_form_errors()
                if formset_non_form_errors:
                    total_error_count += len(formset_non_form_errors)
                    non_form_errors.extend(
                        [f"Properties: {error}" for error in formset_non_form_errors]
                    )
                
                # Count individual form errors (field and non-field)
                for form in formset.forms:
                    # Count field errors for each form using standard API
                    total_error_count += len( form.non_field_errors() )
                    for field_name in form.fields:
                        total_error_count += len( form[field_name].errors )
                        continue
        
        edit_form_data.error_count = total_error_count
        return non_form_errors

    def create_upload_form( self,
                            attr_item_context  : AttributeItemEditContext,
                            request            : HttpRequest ) -> AttributeUploadForm:
        assert attr_item_context.uses_file_uploads

        AttributeUploadFormClass = attr_item_context.attribute_upload_form_class
        owner_attribute = attr_item_context.create_attribute_model()
        return AttributeUploadFormClass(
            request.POST,
            request.FILES,
            instance = owner_attribute,
        )

    def validate_upload_form( self, attribute_upload_form : AttributeUploadForm ) -> bool:
        return attribute_upload_form.is_valid()
    
    def save_upload_form( self, attribute_upload_form : AttributeUploadForm ) -> None:
        with transaction.atomic():
            attribute_upload_form.save()   
        return
    
    def create_multi_edit_form_data(
            self,
            attr_item_context_list  : List[AttributeItemEditContext],
            form_data               : Optional[ Dict[str, Any] ] = None ) -> List[AttributeMultiEditFormData]:

        multi_edit_form_data_list = list()
        for attr_item_context in attr_item_context_list:
            edit_form_data = self.create_edit_form_data(
                attr_item_context = attr_item_context,
                form_data = form_data,
            )
            multi_edit_form_data = AttributeMultiEditFormData(
                attr_item_context = attr_item_context,
                edit_form_data = edit_form_data,
            )
            multi_edit_form_data_list.append( multi_edit_form_data )
            continue
        return multi_edit_form_data_list

    def validate_forms_multi(
            self,
            multi_edit_form_data_list : List[AttributeMultiEditFormData] ) -> bool:

        if settings.DEBUG and settings.DEBUG_INJECT_ATTRIBUTE_FORM_ERRORS:
            for multi_edit_form_data in multi_edit_form_data_list:
                self.validate_forms( edit_form_data = multi_edit_form_data.edit_form_data )
                continue
            return False
        
        for multi_edit_form_data in multi_edit_form_data_list:
            if not self.validate_forms( edit_form_data = multi_edit_form_data.edit_form_data ):
                return False
            continue
        return True

    def save_forms_multi(
            self,
            multi_edit_form_data_list  : List[AttributeMultiEditFormData],
            request                    : HttpRequest ) -> None:
        for multi_edit_form_data in multi_edit_form_data_list:
            self.save_forms(
                attr_item_context = multi_edit_form_data.attr_item_context,
                edit_form_data = multi_edit_form_data.edit_form_data,
                request = request,
            )
            continue
        return True
            
    def collect_form_errors_multi(
            self,
            multi_edit_form_data_list  : List[AttributeMultiEditFormData] ) -> List[str]:

        non_form_errors = list()
        for multi_edit_form_data in multi_edit_form_data_list:
            errors = self.collect_form_errors(
                edit_form_data = multi_edit_form_data.edit_form_data,
            )
            non_form_errors.extend( errors )
            continue

        return non_form_errors