Añadidos endpoints de validación, organización del backend en subcarpetas y archivos y añadido el control de errores http.

backend/api/models/docmf_models.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel, field_validator
+from typing import List, Tuple
+
+class DoCMFRequest(BaseModel):
+    term: str
+    core: Tuple[float, float]
+    support: Tuple[float, float]
+    left_nodes_x: List[float]
+    left_blank_cards: List[int]
+    right_nodes_x: List[float]
+    right_blank_cards: List[int]
+
+    @field_validator("term")
+    def term_not_empty(cls, v):
+        if not v.strip():
+            raise ValueError("El término no puede estar vacío.")
+        return v
+
+    @field_validator("core")
+    def core_valid(cls, v):
+        a, b = v
+        if a > b:
+            raise ValueError("El núcleo debe cumplir a <= b.")
+        return v
+
+    @field_validator("support")
+    def support_valid(cls, v, info):
+        c, d = v
+        if c >= d:
+            raise ValueError("El soporte debe cumplir c < d.")
+
+        core = info.data.get("core")
+        if core:
+            a, b = core
+            if not (c <= a < b <= d):
+                raise ValueError("El núcleo debe estar dentro del soporte.")
+        return v
+
+    @field_validator("left_blank_cards", "right_blank_cards")
+    def cards_valid(cls, v):
+        if any(c < 0 for c in v):
+            raise ValueError("Las cartas no pueden ser negativas.")
+        return v

backend/api/models/docmf_simple_validation_models.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel, field_validator
+from typing import List, Tuple
+
+class SimpleLevelDefinition(BaseModel):
+    core: Tuple[float, float]
+    support: Tuple[float, float]
+
+    @field_validator("core")
+    def validate_core(cls, v):
+        a, b = v
+        if a >= b:
+            raise ValueError("El núcleo debe cumplir a < b.")
+        return v
+
+    @field_validator("support")
+    def validate_support(cls, v):
+        c, d = v
+        if c >= d:
+            raise ValueError("El soporte debe cumplir c < d.")
+        return v
+
+
+class SimpleValidationRequest(BaseModel):
+    levels: List[SimpleLevelDefinition]

backend/api/models/docmf_validation_models.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel, field_validator
+from typing import List, Tuple
+
+class LevelDefinition(BaseModel):
+    core: Tuple[float, float]
+    support: Tuple[float, float]
+    left_nodes: List[Tuple[float, float]]
+    right_nodes: List[Tuple[float, float]]
+
+    @field_validator("core")
+    def validate_core(cls, v):
+        a, b = v
+        if a >= b:
+            raise ValueError("El núcleo debe cumplir a < b.")
+        return v
+
+    @field_validator("support")
+    def validate_support(cls, v):
+        c, d = v
+        if c >= d:
+            raise ValueError("El soporte debe cumplir c < d.")
+        return v
+
+    @field_validator("left_nodes", "right_nodes")
+    def validate_nodes(cls, v):
+        if len(v) < 2:
+            raise ValueError("Debe haber al menos 2 nodos.")
+        xs = [p[0] for p in v]
+        if xs != sorted(xs):
+            raise ValueError("Los nodos deben estar ordenados por x.")
+        if len(xs) != len(set(xs)):
+            raise ValueError("Los nodos no pueden tener valores x duplicados.")
+        return v
+
+
+class ValidationRequest(BaseModel):
+    levels: List[LevelDefinition]

backend/api/models/evaluation_models.py

@@ -0,0 +1,35 @@
+from pydantic import BaseModel, field_validator
+from typing import List, Tuple
+
+class EvaluationRequest(BaseModel):
+    x: float
+    core: Tuple[float, float]
+    support: Tuple[float, float]
+    left_nodes: List[Tuple[float, float]]
+    right_nodes: List[Tuple[float, float]]
+
+    @field_validator("core")
+    def core_valid(cls, v):
+        a, b = v
+        if a > b:
+            raise ValueError("El núcleo debe cumplir a <= b.")
+        return v
+
+    @field_validator("support")
+    def support_valid(cls, v, info):
+        c, d = v
+        if c >= d:
+            raise ValueError("El soporte debe cumplir c < d.")
+
+        core = info.data.get("core")
+        if core:
+            a, b = core
+            if not (c <= a < b <= d):
+                raise ValueError("El núcleo debe estar dentro del soporte.")
+        return v
+
+    @field_validator("left_nodes", "right_nodes")
+    def nodes_valid(cls, v):
+        if len(v) < 2:
+            raise ValueError("Debe haber al menos 2 nodos.")
+        return v

backend/api/models/value_function_models.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel, field_validator
+from typing import List, Dict
+
+class ValueFunctionRequest(BaseModel):
+    criterion_name: str
+    levels: List[str]
+    blank_cards: List[int]
+    references: Dict[str, float]
+
+    @field_validator("criterion_name")
+    def name_not_empty(cls, v):
+        if not v.strip():
+            raise ValueError("El nombre no puede estar vacío.")
+        return v
+
+    @field_validator("levels")
+    def levels_not_empty(cls, v):
+        if len(v) < 2:
+            raise ValueError("Debe haber al menos 2 niveles.")
+        return v
+
+    @field_validator("blank_cards")
+    def cards_valid(cls, v, info):
+        if any(c < 0 for c in v):
+            raise ValueError("Las cartas no pueden ser negativas.")
+
+        levels = info.data.get("levels")
+        if levels and len(v) != len(levels) - 1:
+            raise ValueError("Debe haber uno menos de número de cartas blancas que de niveles.")
+        return v
+
+    @field_validator("references")
+    def refs_valid(cls, v):
+        if len(v) != 2:
+            raise ValueError("Debe haber 2 referencias.")
+        return v