Merge pull request #167 from Rafalkufel/143-student-form-validation

143-Refactor validation flow + child tabl validation

Author: Rafalkufel

alinka/constants/common.py

@@ -1,6 +1,7 @@
 from enum import Enum, StrEnum
 
 RPSO_SUPPORT_CENTER_TYPE_ID = 48
+INVALID_FORM_MESSAGE = "Popraw błędy w formularzu."
 
 
 class DocumentsTypes(Enum):

alinka/rspo_client.py

@@ -35,6 +35,7 @@ def wrapper(*args, **kwargs):
             formatted_path = path.format(**kwargs)
             url = os.path.join(settings.RSPO_DOMAIN, formatted_path)
             response = request(method=method, url=url, params=params, json=body)
+            response.raise_for_status()
             return type_adapter.validate_python(response.json())
 
         return wrapper

alinka/widget/components.py

@@ -1,4 +1,4 @@
-from PySide6.QtGui import QValidator
+from PySide6.QtCore import Signal
 from PySide6.QtWidgets import (
     QCheckBox,
     QComboBox,
@@ -11,107 +11,58 @@
     QWidget,
 )
 
-from alinka.widget.validators import RequiredValidator
+from alinka import rspo_client
 
 
 class ValidationMixin:
-    """Mixin providing reusable validation and highlighting functionality.
-
-    It can be used by any component that needs field validation.
+    """
+    Mixin class to add validation functionality to components/containers
+    Including this mixing ensures that all components/containers have a consistent
+    interface for validation-related methods and properties.
+    Method should be overridden in subclasses as needed.
     """
 
-    def highlight_field(self, field_component: any, highlight: bool) -> None:
-        """Trigger highlighting of a field component with consistent styling.
-
-        Args:
-            field_component: The component to highlight (LabeledInputComponent or LabeledComboBoxComponent)
-            highlight: Whether to highlight (True) or clear highlighting (False)
-        """
-        if not hasattr(field_component, "line_edit") and not hasattr(field_component, "combobox"):
-            return
-
-        widget = getattr(field_component, "line_edit", None) or getattr(field_component, "combobox", None)
-
-        if highlight:
-            widget.setStyleSheet("border: 2px solid #ff4444; background-color: #fff5f5; color: black;")
-        else:
-            widget.setStyleSheet("")
-
-    def validate_required_fields(self, required_fields: list) -> bool:
-        """Validate a list of required fields and highlight missing ones.
-
-        Args:
-            required_fields: List of field components to validate
-
-        Returns:
-            bool: True if all fields are valid, False otherwise
-        """
-        is_valid = True
-
-        for field in required_fields:
-            if not field.is_valid:
-                self.highlight_field(field, True)
-                is_valid = False
-            else:
-                self.highlight_field(field, False)
-
-        return is_valid
-
-    def clear_highlights(self, fields: list) -> None:
-        """Clear highlighting from a list of fields.
-
-        Args:
-            fields: List of field components to clear highlighting from
-        """
-        for field in fields:
-            self.highlight_field(field, False)
-
-    def connect_field_clear_handlers(self, fields: list) -> None:
-        """Connect text change handlers to clear highlights when users start typing.
-
-        Args:
-            fields: List of field components to connect handlers to
-        """
-        for field in fields:
-            if hasattr(field, "line_edit"):
-                # For input fields, clear highlight when text changes
-                field.line_edit.textChanged.connect(lambda checked, f=field: self.highlight_field(f, False))
-            elif hasattr(field, "combobox"):
-                # For combobox fields, clear highlight when selection changes
-                field.combobox.currentTextChanged.connect(lambda text, f=field: self.highlight_field(f, False))
-                # Also connect to currentIndexChanged for more reliable triggering
-                field.combobox.currentIndexChanged.connect(lambda index, f=field: self.highlight_field(f, False))
-
-
-class BaseComponent(QFrame):
     @property
     def is_valid(self) -> bool:
-        """
-        Method to check if the component is valid.
-        If this method is not overridden in the subclass, component is always valid.
-        """
+        """Method to check if the component/container is valid."""
         return True
 
     @property
     def error_message(self) -> str | None:
         """
         Method to get the error message if the component is not valid.
-        If this method is not overridden in the subclass, it returns None.
         Return type should be string - if there's error message or None if there's no error.
         """
         return None
 
+    def validate(self) -> bool:
+        """
+        Trigger validation of this component/containers and subclasses.
+        This method should also update the visual state of the component/container
+        to reflect whether it's valid or not (e.g., highlighting fields in red)
+        by calling self.display_validation_result(validation_result)
+        """
+        is_valid = self.is_valid
+        self.display_validation_result(is_valid)
+        return is_valid
 
-class LabeledInputComponent(BaseComponent):
+    def clear_validation_state(self) -> None:
+        """Reset component and it's parent validation state"""
+        pass
+
+    def display_validation_result(self, validation_result: bool) -> None:
+        """Display validation result by updating component's appearance"""
+        pass
+
+
+class LabeledInputComponent(ValidationMixin, QFrame):
     def __init__(
         self,
         text: str,
         parent: QWidget,
         min_length: int | None = None,
         required: bool = False,
-        validator: QValidator | None = None,
     ):
-        self.used_validator = None
         self.label = text
         self.is_required = required
         super().__init__(parent)
@@ -123,13 +74,7 @@ def __init__(
         if min_length:
             self.line_edit.setMinimumWidth(min_length)
 
-        if validator:
-            self.used_validator = validator
-        elif required:
-            self.used_validator = RequiredValidator()
-        if self.used_validator:
-            self.line_edit.setValidator(self.used_validator)
-            self.line_edit.editingFinished.connect(self.validate)
+        self.line_edit.textChanged.connect(self.clear_validation_state)
 
         layout.addWidget(label)
         layout.addWidget(self.line_edit)
@@ -145,32 +90,22 @@ def text(self, text):
     def clear(self) -> None:
         self.line_edit.clear()
 
+    def display_validation_result(self, validation_result: bool) -> None:
+        if validation_result:
+            self.toggle_highlight("lightgreen")
+        else:
+            self.toggle_highlight("mistyrose")
+
     def toggle_highlight(self, color: str | None) -> None:
         if color:
             self.line_edit.setStyleSheet(f"background-color: {color};")
         else:
             self.line_edit.setStyleSheet("")
 
-    def validate(self) -> None:
-        if self.used_validator:
-            validation_state, _, _ = self.used_validator.validate(self.text, 0)
-            if validation_state != QValidator.Acceptable:
-                self.toggle_highlight("mistyrose")
-            else:
-                self.toggle_highlight(None)
-
     @property
     def is_valid(self) -> bool:
-        # For required fields without a specific validator, check if they have content
-        if self.is_required and not self.used_validator:
+        if self.is_required:
             return bool(self.text.strip())
-
-        # For fields with validators, check the validation state
-        if self.used_validator:
-            validation_state, _, _ = self.used_validator.validate(self.text, 0)
-            return validation_state == QValidator.Acceptable
-
-        # For non-required fields without validators, always valid
         return True
 
     @property
@@ -180,17 +115,26 @@ def error_message(self) -> str | None:
         if self.used_validator and not self.is_valid:
             return self.used_validator.default_error_message
 
+    def clear_validation_state(self) -> None:
+        """Reset component and it's parent validation state"""
+        self.parent().clear_validation_state()
+        self.toggle_highlight(None)
 
-class LabeledComboBoxComponent(BaseComponent):
+
+class LabeledComboBoxComponent(ValidationMixin, QFrame):
     def __init__(
         self,
         text: str,
         parent: QWidget,
         min_length: int | None = None,
         required: bool = False,
+        static: bool = False,
     ):
         self.label = text
         self.is_required = required
+        # If static, options won't change dynamically, e.g. school types
+        # clear means in this case remove selection only
+        self.is_static = static
         super().__init__(parent)
         layout = QVBoxLayout(self)
         layout.setContentsMargins(0, 0, 0, 0)
@@ -200,6 +144,7 @@ def __init__(
         if min_length:
             self.combobox.setMinimumWidth(min_length)
 
+        self.combobox.currentIndexChanged.connect(self.clear_validation_state)
         layout.addWidget(label)
         layout.addWidget(self.combobox)
 
@@ -213,12 +158,37 @@ def text(self, text):
         if index >= 0:
             self.combobox.setCurrentIndex(index)
 
-    def clear(self) -> None:
+    def remove_selection(self) -> None:
+        self.combobox.setCurrentIndex(-1)
+
+    def clear_options(self) -> None:
         self.combobox.clear()
 
+    def clear(self) -> None:
+        self.remove_selection()
+        if not self.is_static:
+            self.clear_options()
+
     def addItems(self, items: list[str]) -> None:
         self.combobox.addItems(items)
 
+    def display_validation_result(self, validation_result: bool) -> None:
+        if validation_result:
+            self.toggle_highlight("lightgreen")
+        else:
+            self.toggle_highlight("mistyrose")
+
+    def toggle_highlight(self, color: str | None) -> None:
+        if color:
+            self.combobox.setStyleSheet(f"background-color: {color};")
+        else:
+            self.combobox.setStyleSheet(None)
+
+    def clear_validation_state(self) -> None:
+        """Reset component and it's parent validation state"""
+        self.parent().clear_validation_state()
+        self.toggle_highlight(None)
+
     @property
     def is_valid(self) -> bool:
         if not self.is_required:
@@ -232,7 +202,7 @@ def error_message(self) -> str | None:
         return None
 
 
-class LabeledCheckboxComponent(BaseComponent):
+class LabeledCheckboxComponent(ValidationMixin, QFrame):
     def __init__(self, text, parent, label_position: str = "above"):
         super().__init__(parent)
         label = QLabel(text=text, parent=self)
@@ -246,8 +216,11 @@ def __init__(self, text, parent, label_position: str = "above"):
         else:
             layout.addWidget(self.checkbox)
 
+    def clear(self) -> None:
+        self.checkbox.setChecked(False)
+
 
-class LabeledDateComponent(BaseComponent):
+class LabeledDateComponent(ValidationMixin, QFrame):
     def __init__(self, text, parent):
         super().__init__(parent)
         layout = QVBoxLayout(self)
@@ -258,3 +231,61 @@ def __init__(self, text, parent):
         self.date_input.dateTime()
         layout.addWidget(label)
         layout.addWidget(self.date_input)
+
+    def clear(self) -> None:
+        self.date_input.clear()
+
+
+class SelectProvinceDistrictGroup(ValidationMixin, QFrame):
+    """Generic component to select provinece and district from RPSO"""
+
+    selection_changed = Signal()
+
+    def __init__(self, parent: QWidget):
+        super().__init__(parent)
+        self.select_school_group = parent
+
+        location_frame_layout = QHBoxLayout(self)
+        location_frame_layout.setContentsMargins(0, 0, 0, 0)
+        self.province_combobox = LabeledComboBoxComponent("Województwo", self, required=True)
+        self.province_combobox.combobox.setPlaceholderText("Wybierz z listy...")
+        self.province_combobox.combobox.currentTextChanged.connect(self.on_province_changed)
+
+        provinces = rspo_client.list_provinces()
+        for province in provinces:
+            self.province_combobox.combobox.addItem(province.name, province.id)
+
+        self.district_combobox = LabeledComboBoxComponent("Powiat", self, required=True)
+        self.district_combobox.combobox.setPlaceholderText("Wybierz z listy...")
+        self.district_combobox.combobox.currentTextChanged.connect(self.on_district_changed)
+        location_frame_layout.addWidget(self.province_combobox)
+        location_frame_layout.addWidget(self.district_combobox)
+
+    @property
+    def province_id(self) -> int | None:
+        return self.province_combobox.combobox.currentData()
+
+    @property
+    def district_id(self) -> int | None:
+        return self.district_combobox.combobox.currentData()
+
+    def populate_districts_combobox(self) -> None:
+        self.district_combobox.combobox.clear()
+        if not self.province_id:
+            return
+        districts = rspo_client.list_districts(province_id=self.province_id)
+        for district in districts:
+            self.district_combobox.combobox.addItem(district.name, district.id)
+
+    def on_province_changed(self):
+        """
+        In case of province change we should clear all other selections and
+        repopulate districts combobox
+        """
+        self.selection_changed.emit()
+        self.district_combobox.combobox.clear()
+        self.populate_districts_combobox()
+
+    def on_district_changed(self):
+        """In case of district change we should only trigger selection changed signal"""
+        self.selection_changed.emit()

alinka/widget/containers/main_body/__init__.py

@@ -1,11 +1,13 @@
 from PySide6.QtWidgets import QFrame, QVBoxLayout, QWidget
 
+from alinka.widget.components import ValidationMixin
+
 from .content import ContentContainer
 from .footer import FooterContainer
 from .header import HeaderContainer
 
 
-class MainBody(QFrame):
+class MainBody(ValidationMixin, QFrame):
     def __init__(self, parent: QWidget):
         super().__init__(parent)
         self.central_widget = parent