Collective University Scorm

Module Specification
09.27.2016

Nicholas Sardo

Collective Innovation

Overview
The Scorm module will supply playing of all versions of scorm content, manage users,
including managing the courses they are taking and supplying of all related metrics
including but not limited to their progress through a course, test results, etc. In essence,
your Module will be a stand-alone web app (that can be run on a LAMP stack or
equivalent). The Collective University Application will call into the scorm module via REST
as described in the spec. Courses in the players DB will need to include a record for
company_id. It is via this company_id that we can differentiate which courses belong to
which companys, and if a student can take that course.
In addition to the REST functionality, the SCORM Module needs to generate a url from
which it will play a course. The flow would be thus:
REST request to SCORM Module giving user, password, and course_id. If valid, the
SCORM app would return a url from which that course will play (included in the player
are any necessary and/or customary scorm widgets, controls, etc.). The url returned will
be opened in an iframe within the Collective University App.
In all JSON returns involving SCORM courses, you must include your DBs id for that
course.
Bear in mind that this is a living spec, and may be amended, but such amendments if
made, will be minor tweaks and not major features.
The SCORM player should import and play properly all 2004 versions and SCORM V1.2

Goals
1. Creation of a stand-alone player for all versions of SCORM course content
2. Allow addition of courses, students, etc.
3. Track all related metrics
4. REST interface to functionality of player

Specifications
The SCORM Module will be a stand-alone application, tech-stack agnostic (meaning the
developer can use whatever main-stream open source stack they wish), that will present
a REST interface, as well as play specific content, track metrics, etc.

Rest Interface
The Collective University Application will send a request to the player in the form of a
JSON object containing student credentials, and the id of a specific course (the id number
in your database for the course:
{ user: <user>, pass: <password>, course: <course_id> }
The SCORM Module will respond with a JSON object containing either success or error in
login, and if successful, will generate and return a url that will play the requested course
for the requested user (student):
{ error: <reason> }
OR
{ action: success, url: http://<scorm_module_url>/<scorm_player_page> }

Additionally, the SCORM Module needs to give the following functionality, accessed via REST:

Creation of users:
Collective University App will send:
{ action: create_user, user: <user-name>, pass: <password>, company_id:
<company_id> }
SCORM Module will return either:
{ response: user-created, id: <scorm-module-assigned-id> }
OR { error: <reason>

Upload a course:
The developer can choose how they wish to implement this. The action that needs to
occur is sending a JSON object indicating the intent to add a course. The object will also
contain a company id. This id is how we will identify which courses a student can take,
based on which company (or well use a specific number indicating the course is available
to anyone). So, create whatever protocol works best for you, within these parameters.

Delete a course:
Collective University App will send:
{ action: delete-course, company_id: <company_id>, course_id: <course_id> }
The SCORM Module will return either:
{ response: success }
OR { error: <reason> }

List of Courses:
Collective University App will send a JSON object via REST, indicating the desired courses
to list as follows-- NOTE: ALL RETURNED COURSES MUST INCLUDE YOUR SCORM
MODULES ID FOR THE COURSE.

{ action: course-status, user: <user>, company_id: <company-id>, course-id:

<course-id> }
The SCORM Module will return this users status for the course specified. I.E has the
course been started yet, is it in progress, or is it completed
{ response: <specified-course-status> }
OR
{ error: <reason> }

{ action: list-all-courses }
The SCORM Module will return a complete list of all courses via JSON:
{ response: [ <list-of-courses--name-and-id> ] }
OR { error: <reason> }

{ action: courses-started, user: <user>, company_id: <company-id> }

(This is a convenience method) The SCORM Module will return a list of all courses that
have been started by this user in this company
{ response: <list-of-course-names-with-id-started-by-this-user> }
OR
{ error: <reason> }

(This is a convenience method) The SCORM Module will return a list of all courses that
have been completed by this user in this company
{ action: courses-completed, user: <user>, company_id: <company-id> }
SCORM Module Response:
{ response: <list-of course-names-with-id-completed-by-this-user> }
OR
{ error: <reason> }

{ action: list-company-courses, company_id: <company_id> }

The SCORM Module will return a list of all courses that are assigned the requested
company_id via a JSON Object.
{ response: [ <list-of-all-courses-with-company-id--including-scorm-course-id> ] }
OR { error: <reason> }

{ action: list-student-courses, user: <user>, company_id: <company_id> }

The SCORM Module will return a list of all courses the listed user (student) is currently
taking, and have completed in a JSON Object like the following:
{ response: success, current-courses: [ ], completed-courses: [] }

OR { error: <reason> }

Metrics Returned Via REST Request:

You can decide how best you want to implement this. Essentially, this will be like a DB
query. Our JSON REST REquest will contain the user (student), comapny_id, course_id,
and name of metric(s). The query response from the SCORM Module needs to be in
JSON.

Milestones
I.

Plays all versions of SCORM courses

This includes accepting REST request for course, return of URL to play specific
course for specific user, and the proper behavior of player for that course (and that user),
including any standard or customary controls for player. Also, that the player properly
collects and tracks metrics. 30% of payment

II.

Allows Upload and Deletion of SCORM Courses via REST Interface

Confirmation that individual courses can be added or deleted via REST, and in the
case of uploaded courses, that they properly play in player, track metrics, etc. 30% of
payment

III.

All Required REST functionality

All required REST calls work as described. 40% of payment.