changes

fusion_plating/fusion_plating_jobs/models/fp_job_step.py

@@ -326,6 +326,98 @@ class FpJobStep(models.Model):
                 )) % (step.name, old, new, new - old, self.env.user.name))
         return True
 
+    def action_finish_and_advance(self):
+        """Steelhead-style "Finish & Next" — finish this step then auto-
+        start the next pending/ready step in sequence. Single click
+        replaces the prior Finish-then-Move-wizard dance.
+
+        If the step has authored step_input prompts AND none have been
+        captured yet, we route through the simplified Record Inputs
+        wizard first; saving the wizard re-enters here with the
+        `fp_after_inputs=True` context flag so we don't loop.
+        """
+        self.ensure_one()
+        if self.state != 'in_progress':
+            raise UserError(_(
+                "Step '%s' is in state '%s' — start it before clicking Finish."
+            ) % (self.name, self.state))
+
+        # Prompt-first behaviour: show the Record Inputs dialog when the
+        # recipe step has authored prompts and nothing has been captured
+        # in this run. Bypass when context flag is set (i.e. we're being
+        # called BACK from the wizard's commit), or when the operator
+        # already saved values via the Record Inputs button earlier.
+        if (not self.env.context.get('fp_after_inputs')
+                and self._fp_has_uncaptured_step_inputs()):
+            return self._fp_open_input_wizard(advance_after=True)
+
+        self.button_finish()
+        next_step = self._fp_next_runnable_step()
+        if next_step:
+            next_step.with_context(
+                fp_skip_predecessor_check=True,
+            ).button_start()
+            self.job_id.message_post(body=_(
+                'Step "%(prev)s" finished — auto-started next step "%(next)s".'
+            ) % {'prev': self.name, 'next': next_step.name})
+        return True
+
+    def _fp_next_runnable_step(self):
+        """The lowest-sequence step on this job that isn't terminal yet
+        and isn't this one. Used by action_finish_and_advance."""
+        self.ensure_one()
+        candidates = self.job_id.step_ids.filtered(
+            lambda s: s.id != self.id
+            and s.state in ('pending', 'ready', 'paused')
+        ).sorted('sequence')
+        return candidates[:1] or self.env['fp.job.step']
+
+    def _fp_has_uncaptured_step_inputs(self):
+        """True when the recipe step defines step_input prompts AND
+        the user hasn't already saved values for this step's current
+        run via the Record Inputs wizard.
+        """
+        self.ensure_one()
+        node = self.recipe_node_id
+        if not node:
+            return False
+        prompts = node.input_ids
+        if 'kind' in prompts._fields:
+            prompts = prompts.filtered(lambda i: i.kind == 'step_input')
+        if not prompts:
+            return False
+        # Has the operator already recorded values during this run?
+        # Heuristic: any in-place fp.job.step.move (transfer_type='step')
+        # for this step since date_started.
+        Move = self.env['fp.job.step.move']
+        already = Move.search_count([
+            ('from_step_id', '=', self.id),
+            ('transfer_type', '=', 'step'),
+            ('move_datetime', '>=', self.date_started or fields.Datetime.now()),
+        ])
+        return already == 0
+
+    def _fp_open_input_wizard(self, advance_after=False):
+        """Open the simplified Record Inputs dialog. When advance_after
+        is True, the wizard's Save button finishes the step and starts
+        the next one as a single atomic flow."""
+        self.ensure_one()
+        action = self.env['ir.actions.act_window']._for_xml_id(
+            'fusion_plating_jobs.action_fp_job_step_input_wizard'
+        )
+        action['context'] = {
+            **dict(self.env.context),
+            'default_step_id': self.id,
+            'active_id': self.id,
+            'fp_advance_after_save': advance_after,
+        }
+        return action
+
+    # NB: action_open_input_wizard is defined further down (line ~829)
+    # — that one stays as the per-row "Record" button entry-point.
+    # _fp_open_input_wizard above adds the advance_after pathway used
+    # only by action_finish_and_advance.
+
     def button_finish(self):
         """Override to:
           1) Auto-spawn a bake.window when a wet plating step finishes