Revert "feat(jobs): step sequences are 1, 2, 3, ... not 10, 20, 30, ..."

This reverts commit 32d48ea44d.

fusion_plating/fusion_plating/controllers/recipe_controller.py

@@ -53,7 +53,7 @@ class FpRecipeController(http.Controller):
             'name': name,
             'node_type': node_type,
             'parent_id': parent.id,
-            'sequence': max_seq + 1,
+            'sequence': max_seq + 10,
         }
         if vals:
             data.update(vals)
@@ -132,7 +132,7 @@ class FpRecipeController(http.Controller):
         Node = request.env['fusion.plating.process.node']
         try:
             for idx, nid in enumerate(node_ids):
-                Node.browse(int(nid)).write({'sequence': idx + 1})
+                Node.browse(int(nid)).write({'sequence': (idx + 1) * 10})
             return {'ok': True}
         except Exception as exc:
             _logger.exception('Recipe reorder failed')
@@ -195,7 +195,7 @@ class FpRecipeController(http.Controller):
         if a_seq == b_seq:
             # Sequences collided — renumber everyone cleanly, then swap
             for i, s in enumerate(siblings, 1):
-                s.sequence = i
+                s.sequence = i * 10
             a_seq, b_seq = node.sequence, other.sequence
         node.sequence, other.sequence = b_seq, a_seq
         return {'ok': True}
@@ -260,7 +260,7 @@ class FpRecipeController(http.Controller):
             vals['sequence'] = base_seq
             new_node = Node.create(vals)
             for i, child in enumerate(src_node.child_ids.sorted('sequence'), 1):
-                _copy_subtree(child, new_node, i)
+                _copy_subtree(child, new_node, i * 10)
             return new_node
 
         # Phase 1 — create every copied top-level child, tracking their
@@ -308,8 +308,8 @@ class FpRecipeController(http.Controller):
             + existing_top[anchor_idx:]
         )
         for i, node in enumerate(final_order, 1):
-            if node.sequence != i:
-                node.sequence = i
+            if node.sequence != i * 10:
+                node.sequence = i * 10
 
         return {
             'ok': True,
@@ -341,7 +341,7 @@ class FpRecipeController(http.Controller):
             max_seq = max((c.sequence for c in parent.child_ids), default=0)
             node.write({
                 'parent_id': parent.id,
-                'sequence': max_seq + 1,
+                'sequence': max_seq + 10,
             })
             return {'ok': True}
         except Exception as exc:

fusion_plating/fusion_plating/controllers/simple_recipe_controller.py

@@ -271,7 +271,7 @@ class SimpleRecipeController(http.Controller):
             'template_id': tpl.id,
             'name': (payload or {}).get('name') or 'New Prompt',
             'input_type': (payload or {}).get('input_type') or 'text',
-            'sequence': existing_max + 1,
+            'sequence': existing_max + 10,
             'required': bool((payload or {}).get('required')),
         })
         return {'ok': True, 'input_id': rec.id,
@@ -356,26 +356,25 @@ class SimpleRecipeController(http.Controller):
         return {'id': new_node.id, 'sequence': new_node.sequence}
 
     def _sequence_for_position(self, recipe, position):
-        """Return the sequence value for a NEW step inserted at
-        `position` among the recipe's existing children.
-
-        Always renumbers existing siblings so the result is contiguous
-        1, 2, 3, ... matching what the operator sees on the work order.
-        (Pre-Sub 13c we used 10-spacing to allow midpoint inserts —
-        operators kept asking why their first step said "Step 10".)
-        """
         siblings = recipe.child_ids.sorted('sequence')
         if not siblings:
-            return 1
-        pos = max(0, min(position, len(siblings)))
-        # Make room: siblings before `pos` keep their 1-based index;
-        # siblings at or after `pos` shift up by one so the new step
-        # lands at sequence (pos + 1).
+            return 10
+        if position >= len(siblings):
+            return siblings[-1].sequence + 10
+        if position <= 0:
+            return max(1, siblings[0].sequence - 10)
+        before = siblings[position - 1].sequence
+        after = siblings[position].sequence
+        if after - before > 1:
+            return (before + after) // 2
+        # Sequences are tightly packed (gap == 1 → midpoint == after,
+        # which collides). Renumber siblings to 10/20/30… first, then
+        # the new step lands cleanly between renumbered neighbours.
         for idx, sib in enumerate(siblings):
-            target = idx + 1 if idx < pos else idx + 2
-            if sib.sequence != target:
-                sib.sequence = target
-        return pos + 1
+            new_seq = (idx + 1) * 10
+            if sib.sequence != new_seq:
+                sib.sequence = new_seq
+        return position * 10 + 5
 
     def _copy_inputs_from_template(self, tpl, new_node):
         NodeInput = request.env['fusion.plating.process.node.input']
@@ -413,7 +412,7 @@ class SimpleRecipeController(http.Controller):
     def step_reorder(self, node_ids):
         Node = request.env['fusion.plating.process.node']
         for i, nid in enumerate(node_ids, start=1):
-            Node.browse(nid).write({'sequence': i})
+            Node.browse(nid).write({'sequence': i * 10})
         return {'ok': True}
 
     # -------------------------------------------------------------- template
@@ -522,7 +521,7 @@ class SimpleRecipeController(http.Controller):
             'input_type': (payload or {}).get('input_type') or 'text',
             'kind': 'step_input',
             'collect': True,
-            'sequence': existing_max + 1,
+            'sequence': existing_max + 10,
             'required': bool((payload or {}).get('required')),
         })
         return {'ok': True, 'input_id': rec.id}