factors: -> stage

passbook/flows/planner.py

@@ -7,7 +7,7 @@ from django.http import HttpRequest
 from structlog import get_logger
 
 from passbook.flows.exceptions import FlowNonApplicableError
-from passbook.flows.models import Factor, Flow
+from passbook.flows.models import Flow, Stage
 from passbook.policies.engine import PolicyEngine
 
 LOGGER = get_logger()
@@ -19,19 +19,19 @@ PLAN_CONTEXT_SSO = "is_sso"
 @dataclass
 class FlowPlan:
     """This data-class is the output of a FlowPlanner. It holds a flat list
-    of all Factors that should be run."""
+    of all Stages that should be run."""
 
-    factors: List[Factor] = field(default_factory=list)
+    stages: List[Stage] = field(default_factory=list)
     context: Dict[str, Any] = field(default_factory=dict)
 
-    def next(self) -> Factor:
-        """Return next pending factor from the bottom of the list"""
-        factor_cls = self.factors.pop(0)
-        return factor_cls
+    def next(self) -> Stage:
+        """Return next pending stage from the bottom of the list"""
+        stage_cls = self.stages.pop(0)
+        return stage_cls
 
 
 class FlowPlanner:
-    """Execute all policies to plan out a flat list of all Factors
+    """Execute all policies to plan out a flat list of all Stages
     that should be applied."""
 
     flow: Flow
@@ -45,7 +45,7 @@ class FlowPlanner:
         return engine.result
 
     def plan(self, request: HttpRequest) -> FlowPlan:
-        """Check each of the flows' policies, check policies for each factor with PolicyBinding
+        """Check each of the flows' policies, check policies for each stage with PolicyBinding
         and return ordered list"""
         LOGGER.debug("Starting planning process", flow=self.flow)
         start_time = time()
@@ -56,13 +56,18 @@ class FlowPlanner:
         if not root_passing:
             raise FlowNonApplicableError(root_passing_messages)
         # Check Flow policies
-        for factor in self.flow.factors.order_by("order").select_subclasses():
-            engine = PolicyEngine(factor.policies.all(), request.user, request)
+        for stage in (
+            self.flow.stages.order_by("flowstagebinding__order")
+            .select_subclasses()
+            .select_related()
+        ):
+            binding = stage.flowstagebinding_set.get(flow__pk=self.flow.pk)
+            engine = PolicyEngine(binding.policies.all(), request.user, request)
             engine.build()
             passing, _ = engine.result
             if passing:
-                LOGGER.debug("Factor passing", factor=factor)
-                plan.factors.append(factor)
+                LOGGER.debug("Stage passing", stage=stage)
+                plan.stages.append(stage)
         end_time = time()
         LOGGER.debug(
             "Finished planning", flow=self.flow, duration_s=end_time - start_time