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

backend/api/services/docmf_build_service.py

@@ -0,0 +1,37 @@
+def build_docmf(request):
+    a, b = request.core
+    c, d = request.support
+
+    # LEFT
+    TL = sum(e + 1 for e in request.left_blank_cards)
+    YL = 1 / TL
+    left_nodes = []
+    acc = 0
+
+    for i, x in enumerate(request.left_nodes_x):
+        if i == 0:
+            left_nodes.append((x, 0.0))
+        else:
+            acc += request.left_blank_cards[i-1] + 1
+            left_nodes.append((x, round(acc * YL, 4)))
+
+    # RIGHT
+    TR = sum(e + 1 for e in request.right_blank_cards)
+    YR = 1 / TR
+    right_nodes = []
+    acc = 0
+
+    for i, x in enumerate(request.right_nodes_x):
+        if i == 0:
+            right_nodes.append((x, 1.0))
+        else:
+            acc += request.right_blank_cards[i-1] + 1
+            right_nodes.append((x, round(1 - acc * YR, 4)))
+
+    return {
+        "term": request.term,
+        "core": request.core,
+        "support": request.support,
+        "left_nodes": left_nodes,
+        "right_nodes": right_nodes
+    }

backend/api/services/docmf_evaluate_service.py

@@ -0,0 +1,22 @@
+from utils.interpolation import linear_interpolation
+
+def evaluate_docmf(request):
+    x = request.x
+    a, b = request.core
+    c, d = request.support
+
+    if x < c or x > d:
+        return {"membership": 0.0, "explanation": "Fuera del soporte."}
+
+    if a <= x <= b:
+        return {"membership": 1.0, "explanation": "Dentro del núcleo."}
+
+    if c <= x < a:
+        mu = linear_interpolation(x, request.left_nodes)
+        return {"membership": mu, "explanation": f"El valor x={x} se interpola entre los nodos {request.left_nodes} del lado izquierdo."}
+
+    if b < x <= d:
+        mu = linear_interpolation(x, request.right_nodes)
+        return {"membership": mu, "explanation": f"El valor x={x} se interpola entre los nodos {request.right_nodes} del lado derecho."}
+
+    raise ValueError("No se pudo evaluar el valor.")

backend/api/services/docmf_simple_validation_service.py

@@ -0,0 +1,25 @@
+def validate_simple_level(level: dict):
+    errors = []
+
+    a, b = level["core"]
+    c, d = level["support"]
+
+    # Validación: núcleo dentro del soporte
+    if not (c <= a < b <= d):
+        errors.append("El núcleo debe estar completamente dentro del soporte.")
+
+    return errors
+
+
+def validate_simple_levels(levels):
+    results = []
+
+    for idx, level in enumerate(levels):
+        errors = validate_simple_level(level.dict())
+        results.append({
+            "level_index": idx,
+            "valid": len(errors) == 0,
+            "errors": errors
+        })
+
+    return results

backend/api/services/docmf_validation_service.py

@@ -0,0 +1,39 @@
+def validate_single_level(level: dict):
+    errors = []
+
+    a, b = level["core"]
+    c, d = level["support"]
+
+    # Core dentro del soporte
+    if not (c <= a < b <= d):
+        errors.append("El núcleo debe estar completamente dentro del soporte.")
+
+    # Nodos cubren correctamente el soporte
+    left = level["left_nodes"]
+    right = level["right_nodes"]
+
+    if left[0][0] != c:
+        errors.append("El primer nodo izquierdo debe coincidir con el inicio del soporte.")
+    if left[-1][0] != a:
+        errors.append("El último nodo izquierdo debe coincidir con el inicio del núcleo.")
+
+    if right[0][0] != b:
+        errors.append("El primer nodo derecho debe coincidir con el final del núcleo.")
+    if right[-1][0] != d:
+        errors.append("El último nodo derecho debe coincidir con el final del soporte.")
+
+    return errors
+
+
+def validate_levels(levels):
+    results = []
+
+    for idx, level in enumerate(levels):
+        errors = validate_single_level(level.dict())
+        results.append({
+            "level_index": idx,
+            "valid": len(errors) == 0,
+            "errors": errors
+        })
+
+    return results

backend/api/services/value_function_service.py

@@ -0,0 +1,38 @@
+def compute_value_function(request):
+    levels = request.levels
+    cards = request.blank_cards
+    refs = request.references
+
+    p, q = sorted(int(k) for k in refs)
+    up, uq = refs[str(p)], refs[str(q)]
+
+    if len(levels) < 3:
+        raise ValueError("Mínimo debe haber 3 niveles para esta funcionalidad.")
+
+    total_units = sum(cards[i] + 1 for i in range(p, q))
+    if total_units == 0:
+        raise ValueError("Las cartas no pueden generar 0 unidades.")
+
+    alpha = (uq - up) / total_units
+
+    values = [0] * len(levels)
+    values[p] = up
+
+    for i in range(p + 1, len(levels)):
+        units = sum(cards[r] + 1 for r in range(p, i))
+        values[i] = up + alpha * units
+
+    for i in range(p - 1, -1, -1):
+        units = sum(cards[r] + 1 for r in range(i, p))
+        values[i] = up - alpha * units
+
+    return {
+        "criterion_name": request.criterion_name,
+        "values": {levels[i]: round(values[i], 4) for i in range(len(levels))}
+    }
+
+
+def compute_points(request):
+    result = compute_value_function(request)
+    values = list(result["values"].values())
+    return {"points": [{"x": i, "y": values[i]} for i in range(len(values))]}