code: def _get_next_child_node(self, parent):
          
          children_keys = list(parent.children)
          sorted_keys = sorted(children_keys)
          for key in sorted_keys:
              node = parent.children[key]
              if node.job_record is None:
                  self.timetable.assign_job_record(node)
                  return node
              elif self.should_skip_tree_node(node):
                  continue
              elif node.job_record.is_active:
                  return node
  
          # special case, when all children of the parent node are not suitable for processing
          new_parent = self._get_next_parent_node(parent)
          if new_parent is not None:
              # in case all nodes are processed or blocked - look for next valid parent node
              return self._get_next_child_node(new_parent)
          else:
              # if all valid parents are exploited - return current node
              process_name = parent.children[sorted_keys[0]].process_name
              time_qualifier = parent.children[sorted_keys[0]].time_qualifier
              actual_timeperiod = time_helper.actual_timeperiod(time_qualifier)
              return self.get_node(process_name, actual_timeperiod)
docs: Iterates among children of the given parent and looks for a suitable node to process
              In case given parent has no suitable nodes, a younger parent will be found
              and the logic will be repeated for him