docs: def commit_workflow(self, workflow_id):
          """
          Commit the workflow to the database
          :param workflow_id: The workflow id
          :return: None
          """
          # TODO: We should also be committing the Stream definitions if there are new ones
  
          workflow = self.workflows[workflow_id]
  
          with switch_db(WorkflowDefinitionModel, "hyperstream"):
              workflows = WorkflowDefinitionModel.objects(workflow_id=workflow_id)
              if len(workflows) > 0:
                  logging.warn("Workflow with id {} already exists in database".format(workflow_id))
                  return
  
              factors = []
              for f in workflow.factors:
                  tool = f.tool.get_model()
  
                  if isinstance(f, Factor):
                      sources = [s.node_id for s in f.sources] if f.sources else []
                      sinks = [f.sink.node_id]
                      alignment_node = f.alignment_node.node_id if f.alignment_node else None
                      splitting_node = None
                      output_plate = None
  
                  elif isinstance(f, MultiOutputFactor):
                      sources = [f.source.node_id] if f.source else []
                      sinks = [f.sink.node_id]
                      alignment_node = None
                      splitting_node = f.splitting_node.node_id if f.splitting_node else None
                      output_plate = None
  
                  elif isinstance(f, NodeCreationFactor):
                      sources = [f.source.node_id] if f.source else []
                      sinks = []
                      alignment_node = None
                      splitting_node = None
                      output_plate = f.output_plate
  
                  else:
                      raise NotImplementedError("Unsupported factor type")
  
                  if output_plate:
                      output_plate_copy = deepcopy(output_plate)
                      if 'parent_plate' in output_plate_copy:
                          del output_plate_copy['parent_plate']
                  else:
                      output_plate_copy = None
  
                  factor = FactorDefinitionModel(
                      tool=tool,
                      factor_type=f.__class__.__name__,
                      sources=sources,
                      sinks=sinks,
                      alignment_node=alignment_node,
                      splitting_node=splitting_node,
                      output_plate=output_plate_copy
                  )
  
                  factors.append(factor)
  
              nodes = []
              for n in workflow.nodes.values():
                  nodes.append(NodeDefinitionModel(
                      stream_name=n.node_id,
                      plate_ids=n.plate_ids,
                      channel_id=n._channel.channel_id
                  ))
  
              workflow_definition = WorkflowDefinitionModel(
                  workflow_id=workflow.workflow_id,
                  name=workflow.name,
                  description=workflow.description,
                  nodes=nodes,
                  factors=factors,
                  owner=workflow.owner,
                  online=workflow.online,
                  monitor=workflow.monitor
              )
  
              workflow_definition.save()
  
          with switch_db(WorkflowStatusModel, db_alias='hyperstream'):
              workflow_status = WorkflowStatusModel(
                  workflow_id=workflow.workflow_id,
                  last_updated=utcnow(),
                  last_accessed=utcnow(),
                  requested_intervals=[]
              )
  
              workflow_status.save()
  
          self.uncommitted_workflows.remove(workflow_id)
          logging.info("Committed workflow {} to database".format(workflow_id))