Any way to automatically navigate user to next course object on prior object completion?

I don't think there's a way to do it with just the UI, however you can react on "Course object fulfillment" events, detect the completion (old:complete = 0, new:complete = 1) and use custom PHP to find the next object. It's possible we could make a Rules action out of it.

$course = course_get_course(course_get_context());
$current = $course->getActive();
$next = $course->getNext();
$prev = $course->getPrev();

$next_url = $next->getUrl(); // Will be "node/X/course-object/Y"

Ha, yeah :) Let me know what you come up with. There isn't much traditional documentation on the Course API however there's a lot of DX once you get into the code with an IDE.

It would be nice to have a Rules action which takes in a course object, and attempts to goes to the prev/next one.

I think you could also simplify it with

// $coid is from Rules, it is the ID of the course object, which is on the Fulfillment as well
$co = course_get_course_object_by_id($coid);
$url = $co->getCourse()->getNext()->getUrl();

I think I'll have a patch to contribute for this; I've got something that works so far (https://www.drupal.org/sandbox/stickywes/2534194).

Hmm some of that code seems copied from Rules.

Wouldn't it be better to build a Rules action (or token) that gets the URL of the next object?

That way you can use the built in Rules redirect action, or any other action - send email for example.

Indeed, that seems a better approach.

Oh, whoops! I never submitted the patch. I'll correct that soon-ish.

This patch provides a rule action that can be used to automatically step over to the next object in a course outline.

The action simply loads the course object of a passed-in course object fulfillment and returns the getURL() value of the next object or NULL if there is no next object.

An example usage can be seen using the Rules import below. When a course object fulfillment is updated, it is checked for completion, and then uses the built-in system redirect rule action to redirect after invoking the new Course rule action.

Use more conditionals to make it match your preferences.

{ "rules_go_to_next_course_object" : {
    "LABEL" : "Go to next course object",
    "PLUGIN" : "reaction rule",
    "OWNER" : "rules",
    "REQUIRES" : [ "rules", "course", "entity" ],
    "ON" : { "course_object_fulfillment_update" : [] },
    "IF" : [
      { "data_is" : { "data" : [ "course-object-fulfillment:complete" ], "value" : "1" } }
    ],
    "DO" : [
      { "course_next_url" : {
          "USING" : { "cof_entity" : [ "course-object-fulfillment" ] },
          "PROVIDE" : { "course_url_fetched" : { "course_url_fetched" : "Fetched Course object URL." } }
        }
      },
      { "redirect" : { "url" : [ "course-url-fetched" ] } }
    ]
  }
}

Thanks, let me review.

It would be ideal if this could be used to get the next/previous *anything*, whether it be URL, the object title, if it was required or not, etc. i.e. not hard coding this to just the next URL.

Just update it to return the whole object, then?

Edit: Nevermind, that wouldn't help what we're trying to make happen in this specific issue.

With just returning the whole object you could get a uri using 'course-obj-fetched:nid:url' in the rule definition but that wouldn't quite be right, because you would get 'node/###' instead of 'course/XXXXX/course-object/YYYYY'.

Are there any reasons I shouldn't define a uri callback for CourseObject entities?

I took another look at this and realized that adding a next/previous property to the course entity works just fine, without needing to add a new rule. I'll have a patch up soonish.

Here's a patch that used to work for this issue's specific request until the course object entity URIs went away several commits ago #2668800: Course Objects lack a URI property.

This adds a next/previous property that enables you to get a course object.

You might be able to use the id of the course object to load a node and then redirect to its URL property, but that's kind of a weird extra step to have to take and it requires knowing that a node is the underlying entity instead of some other entity you might use in the future.