From 7deda89ad0f2667d19f3c496524ec434225a5a5f Mon Sep 17 00:00:00 2001
From: Mireya Cueto Garrido <mireya.cueto.0806@fernando3martos.com>
Date: Mon, 23 Mar 2026 11:16:37 +0100
Subject: [PATCH] =?UTF-8?q?Optimizaci=C3=B3n=20c=C3=B3digo=20del=20POST?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 backend/api/routes.py | 72 ++++++++++++++++++++-----------------------
 1 file changed, 33 insertions(+), 39 deletions(-)

diff --git a/backend/api/routes.py b/backend/api/routes.py
index a5b50bb..e84950b 100644
--- a/backend/api/routes.py
+++ b/backend/api/routes.py
@@ -4,57 +4,51 @@ from typing import List, Dict
 
 app = FastAPI()
 
-# 1. Definimos el modelo de datos basado en el JSON que se enviará desde el frontend
 class ValueFunctionRequest(BaseModel):
     criterion_name: str
     levels: List[str]
     blank_cards: List[int]
     references: Dict[str, float]
 
-# Ruta prueba para probar que todo funciona
 @app.get("/prueba")
-def ruta_de_prueba():
+def prueba():
     return {"mensaje": "¡Hola desde FastAPI! El contenedor de docker está funcionando"}
 
-# 2. Endpoint POST para recibir los datos y calcular los valores
 @app.post("/api/criteria/doc/value-function")
-def calcular_funcion_valor(request: ValueFunctionRequest):
+def calcular(request: ValueFunctionRequest):
     levels = request.levels
-    blank_cards = request.blank_cards
-    refs = request.references
-    
-    # Extraemos las claves de referencia y las convertimos a enteros
-    claves_ref = sorted(int(k) for k in refs.keys())  # ejemplo: [0, 4]
-    p, q = claves_ref  # p = 0, q = 4
+    cards_between_levels = request.blank_cards
+    reference_values = request.references
+
+    # Índices de referencia (por ejemplo 0 y 4)
+    ref_indices = sorted(int(k) for k in reference_values)
+    lower_ref, upper_ref = ref_indices
+
+    # Valores asignados a esas referencias
+    lower_value = reference_values[str(lower_ref)]
+    upper_value = reference_values[str(upper_ref)]
+
+    # Total de unidades entre las referencias
+    total_units = sum(cards_between_levels[i] + 1 for i in range(lower_ref, upper_ref))
+
+    # Valor por unidad
+    unit_value = (upper_value - lower_value) / total_units if total_units else 0
+
+    # Lista de valores finales
+    values = [0] * len(levels)
+    values[lower_ref] = lower_value
+
+    # Hacia arriba
+    for i in range(lower_ref + 1, len(levels)):
+        units = sum(cards_between_levels[r] + 1 for r in range(lower_ref, i))
+        values[i] = lower_value + unit_value * units
+
+    # Hacia abajo
+    for i in range(lower_ref - 1, -1, -1):
+        units = sum(cards_between_levels[r] + 1 for r in range(i, lower_ref))
+        values[i] = lower_value - unit_value * units
 
-    # Valores de referencia
-    up = refs[str(p)]
-    uq = refs[str(q)]
-    
-    # PASO A: Calculamos el número total de unidades elementales 'h' entre p y q
-    h = sum(blank_cards[r] + 1 for r in range(p, q))
-    
-    # PASO B: Calculamos el valor fraccional de una sola unidad 'alpha'
-    alpha = (uq - up) / h if h != 0 else 0
-    
-    # Inicializamos la lista de valores V con el tamaño de los niveles
-    V = [0.0] * len(levels)
-    V[p] = up
-    
-    # PASO C: Calculamos los valores hacia adelante (niveles por encima de p)
-    for i in range(p + 1, len(levels)):
-        suma_unidades = sum(blank_cards[r] + 1 for r in range(p, i))
-        V[i] = up + alpha * suma_unidades
-        
-    # PASO D: Calculamos los valores hacia atrás (niveles por debajo de p)
-    for i in range(p - 1, -1, -1):
-        suma_unidades = sum(blank_cards[r] + 1 for r in range(i, p))
-        V[i] = up - alpha * suma_unidades
-        
-    # Formateamos la respuesta
-    resultado_valores = {levels[i]: round(V[i], 4) for i in range(len(levels))}
-    
     return {
         "criterion_name": request.criterion_name,
-        "values": resultado_valores
+        "values": {levels[i]: round(values[i], 4) for i in range(len(levels))}
     }