scorm_cloud 0.0.3

data/lib/scorm_cloud/base_object.rb

@@ -0,0 +1,23 @@
+module ScormCloud
+	class BaseObject
+
+		def set_attributes(attributes)				
+			attributes.each { |k,v| set_attr(k,v) }
+		end
+
+		def set_attr(k,v)
+			f = "#{to_underscore(k)}=".to_sym
+			if respond_to?(f) 
+				send(f, v)
+			else
+				raise "Object #{self.class} does not respond to #{to_underscore(k)}"
+			end
+		end
+
+   def to_underscore(s)
+     s.gsub(/(.)([A-Z])/,'\1_\2').downcase
+   end
+
+	end
+end
+

data/lib/scorm_cloud/base_service.rb

@@ -0,0 +1,27 @@
+module ScormCloud
+	class BaseService
+
+		def initialize(connection)
+			@connection = connection
+		end
+
+		def connection
+			@connection
+		end
+
+		def self.not_implemented(*methods)
+			methods.each do |method|
+				define_method(method) { raise "Not Implemented: #{method.to_s}" }
+ 			end
+		end
+
+		# Convert xml attributes to hash { :name => value }
+		def xml_to_attributes(xml)
+			xml.elements["/rsp/attributes"].inject({}) { |h,e| 
+				h[e.attributes["name"].to_sym] = e.attributes["value"]
+				h 
+			}
+		end
+
+	end
+end

data/lib/scorm_cloud/connection.rb

@@ -0,0 +1,67 @@
+module ScormCloud
+	class Base
+
+		def initialize(appid, secret)
+			@appid = appid
+			@secret = secret
+		end
+
+		def call(method, params = {})
+			url = prepare_url(method, params)
+			execute_call_xml(url)
+		end
+
+		def call_raw(method, params = {})
+			url = prepare_url(method, params)
+			execute_call_plain(url)
+		end			
+
+		# Get plain response body and parse the XML doc
+		def execute_call_xml(url)
+			doc = REXML::Document.new(execute_call_plain(url))
+			raise create_error(doc) unless doc.elements["rsp"].attributes["stat"] == "ok"
+			doc
+		end
+
+		# Execute the call - returns response body or redirect url
+		def execute_call_plain(url)
+			res = Net::HTTP.get_response(URI.parse(url))
+			case res
+			when Net::HTTPRedirection
+				# Return the new URL
+				res['location']
+			when Net::HTTPSuccess
+				res.body
+			else
+				raise "HTTP Error connecting to scorm cloud: #{res.inspect}"
+			end
+		end
+
+		# Get the URL for the call
+		def prepare_url(method, params = {})
+			timestamp = Time.now.utc.strftime('%Y%m%d%H%M%S')
+			params[:method] = method
+			params[:appid] = @appid
+			params[:ts] = timestamp
+			html_params = params.map { |k,v| "#{k.to_s}=#{v}" }.join("&")
+
+			raw = @secret + params.keys.
+					sort{ |a,b| a.to_s.downcase <=> b.to_s.downcase }.
+					map{ |k| "#{k.to_s}#{params[k]}" }.
+					join
+
+			sig = Digest::MD5.hexdigest(raw)
+			"http://cloud.scorm.com/api?#{html_params}&sig=#{sig}"
+		end
+
+
+		# Create an exception with code & message
+		def create_error(doc)
+			err = doc.elements["rsp"].elements["err"]
+			code = err.attributes["code"]
+			msg = err.attributes["msg"]
+			"Error In Scorm Cloud: Error=#{code} Message=#{msg}"
+		end
+
+	end
+end

data/lib/scorm_cloud/course.rb

@@ -0,0 +1,13 @@
+module ScormCloud
+	class Course < ScormCloud::BaseObject
+
+		attr_accessor :id, :versions, :registrations, :title, :size
+
+		def self.from_xml(element)
+			c = Course.new
+			c.set_attributes(element.attributes)
+			c
+		end
+
+	end
+end

data/lib/scorm_cloud/course_service.rb

@@ -0,0 +1,53 @@
+module ScormCloud
+	class CourseService < BaseService
+
+		not_implemented :import_cours_async, :get_async_import_result,
+				:properties, :get_assets, :update_assets,
+				:get_file_structure, :delete_files, :get_metadata
+
+		# TODO: Handle Warnings
+		def import_course(course_id, path)
+			xml = connection.call("rustici.course.importCourse", :courseid => course_id, :path => path)
+			if xml.elements['//rsp/importresult'].attributes["successful"] == "true"
+				title = xml.elements['//rsp/importresult/title'].text	
+				{ :title => title, :warnings => [] }
+			else
+				nil
+			end
+		end
+
+		def exists(course_id)
+			connection.call_raw("rustici.course.exists", :courseid => course_id).include?("<result>true</result>")
+		end
+
+		def get_attributes(course_id)
+			xml = connection.call("rustici.course.getAttributes", :courseid => course_id)
+			xml_to_attributes(xml)
+		end
+
+		def delete_course(course_id)
+			connection.call("rustici.course.deleteCourse", :courseid => course_id)
+			true
+		end
+
+		def get_manifest(course_id)
+		 	connection.call_raw("rustici.course.getManifest", :courseid => course_id)
+		end
+
+		def get_course_list(options = {})
+			xml = connection.call("rustici.course.getCourseList", options)
+			xml.elements["/rsp/courselist"].map { |e| Course.from_xml(e) }
+		end
+
+		def preview(course_id, redirect_url)
+			connection.launch_url("rustici.course.preview", :courseid => course_id, :redirecturl => redirect_url)
+		end
+
+		def update_attributes(course_id, attributes)
+			xml = connection.call("rustici.course.updateAttributes", attributes.merge({:courseid => course_id}))
+			xml_to_attributes(xml)
+		end
+
+	end
+end
+

data/lib/scorm_cloud/debug_service.rb

@@ -0,0 +1,25 @@
+module ScormCloud
+	class DebugService < BaseService
+
+		def ping()
+			url = "http://cloud.scorm.com/api?method=rustici.debug.ping"
+			data = connection.call_url(url)
+			raise "Bad Server Response" unless data.include?("pong")
+			"pong"
+		end
+
+		def auth_ping()
+			xml = connection.call("rustici.debug.authPing")
+			raise "Bad Server Response" unless xml.elements["/rsp/pong"]
+			"pong"
+		end
+
+		def get_time()
+			xml = connection.call("rustici.debug.getTime")
+			time = xml.elements["//currenttime"]
+			raise "Bad Server Response" unless time
+			time.text
+		end
+
+	end
+end

data/lib/scorm_cloud/dispatch_service.rb

@@ -0,0 +1,9 @@
+module ScormCloud
+	class DispatchService < BaseService
+
+		not_implemented :get_destination_list, :get_destination_info, :create_destination,
+				:update_destination, :delete_destination, :get_dispatch_list, :get_dispatch_info,
+				:create_dispatch, :update_dispatches, :download_dispatches, :delete_dispatches
+			
+	end
+end

data/lib/scorm_cloud/export_service.rb

@@ -0,0 +1,7 @@
+module ScormCloud
+	class ExportService < BaseService
+
+		not_implemented :start, :cancel, :status, :download, :list
+
+	end
+end

data/lib/scorm_cloud/railtie.rb

@@ -0,0 +1,13 @@
+require 'rails'
+require 'scorm_cloud/scorm_rails_helpers'
+
+class ScormCloud::Railtie < Rails::Railtie
+
+	config.scorm_cloud = ActiveSupport::OrderedOptions.new
+
+	initializer "scorm_cloud.scorm_rails_helpers" do
+		ActionController::Base.send :include, ScormCloud::ScormRailsHelpers
+	end
+
+end
+

data/lib/scorm_cloud/registration.rb

@@ -0,0 +1,19 @@
+module ScormCloud
+	class Registration < ScormCloud::BaseObject
+
+		attr_accessor :id, :courseid, :app_id, :registration_id, :course_id,
+				:course_title, :learner_id, :learner_first_name, :learner_last_name,
+				:email, :create_date, :first_access_date, :last_access_date,
+				:completed_date, :instances
+
+		def self.from_xml(element)
+			r = Registration.new
+			r.set_attributes(element.attributes)
+			element.children.each do |element|
+				r.set_attr(element.name, element.text)
+			end
+			r
+		end
+
+	end
+end

data/lib/scorm_cloud/registration_service.rb

@@ -0,0 +1,50 @@
+module ScormCloud
+	class RegistrationService < BaseService
+
+		not_implemented :get_registration_list_results,
+			:get_launch_history, :get_launch_info, :reset_global_objectives,
+			:update_learner_info, :test_registration_post_url
+
+		def create_registration(course_id, reg_id, first_name, last_name, learner_id, options = {})
+			params = options.merge({ 
+				:courseid => course_id,
+				:regid => reg_id,
+				:fname => first_name,
+				:lname => last_name,
+				:learnerid => learner_id
+			})
+			xml = connection.call("rustici.registration.createRegistration", params)
+			!xml.elements["/rsp/success"].nil?
+		end
+
+		def delete_registration(reg_id)
+			xml = connection.call("rustici.registration.deleteRegistration", {:regid => reg_id })
+			!xml.elements["/rsp/success"].nil?
+		end
+
+ 		def get_registration_list(options = {})
+			xml = connection.call("rustici.registration.getRegistrationList", options)
+			xml.elements["/rsp/registrationlist"].map { |e| Registration.from_xml(e) }
+		end
+
+		def get_registration_result(reg_id, format="course")
+			raise "Illegal format argument: #{format}" unless ["course","activity","full"].include?(format)
+			connection.call_raw("rustici.registration.getRegistrationResult", { :regid => reg_id, :format => format })
+		end
+
+		def launch(reg_id, redirect_url, options = {})
+			params = options.merge({ 
+				:regid => reg_id,
+				:redirecturl => redirect_url
+			})
+			connection.launch_url("rustici.registration.launch", params)
+		end
+
+		def reset_registration(reg_id)
+			xml = connection.call("rustici.registration.resetRegistration", {:regid => reg_id })
+			!xml.elements["/rsp/success"].nil?
+		end
+
+
+	end
+end

data/lib/scorm_cloud/reporting_service.rb

@@ -0,0 +1,7 @@
+module ScormCloud
+	class ReportingService < BaseService
+
+		not_implemented :get_account_info, :get_reportage_auth, :launch_report
+
+	end
+end

data/lib/scorm_cloud/scorm_rails_helpers.rb

@@ -0,0 +1,15 @@
+module ScormCloud
+  module ScormRailsHelpers
+
+  	def scorm_cloud
+  		unless @scorm_cloud
+  			@scorm_cloud = ::ScormCloud::ScormCloud.new(
+          ::Rails.configuration.scorm_cloud.appid, 
+          ::Rails.configuration.scorm_cloud.secretkey
+        )
+  		end
+  		@scorm_cloud
+  	end
+
+  end
+end

data/lib/scorm_cloud/tagging_service.rb

@@ -0,0 +1,9 @@
+module ScormCloud
+	class TaggingService < BaseService
+		not_implemented :get_course_tags, :set_course_tags, :add_course_tag,
+				:remove_course_tag, :get_learner_tags, :set_learner_tags, :add_learner_tag,
+				:remove_learner_tag, :get_registration_tags, :set_registration_tags,
+				:add_registration_tag, :remove_registration_tag
+	end
+end
+

data/lib/scorm_cloud/upload_service.rb

@@ -0,0 +1,37 @@
+module ScormCloud
+	class UploadService < BaseService
+
+		not_implemented :get_upload_progress
+
+		def get_upload_token
+			xml = connection.call("rustici.upload.getUploadToken")
+			xml.elements["/rsp/token/id"].text
+		end
+
+		def upload_file(token, path)
+			xml = connection.post("rustici.upload.uploadFile", path, :token => token)
+			xml.elements["/rsp/location"].text
+		end
+
+		def list_files
+			xml = connection.call("rustici.upload.listFiles")
+			xml.elements["//rsp/dir"].map do |f|
+				{
+					:dir => f.parent.attributes["name"],
+					:file => f.attributes["name"], 
+					:modified => f.attributes["modified"],
+					:size => f.attributes["modified"].to_i
+				}
+			end
+		end
+
+		def delete_files files
+			if !files.is_a?(String) && files.is_a?(Enumerable)
+			 	files = files.map { |f| "file=#{f}"}.join('&')
+			end
+			result = connection.call("rustici.upload.deleteFiles", { :file => files })
+			!result.to_s.include?("deleted='false'")
+		end
+
+	end
+end

data/lib/scorm_cloud/version.rb

@@ -0,0 +1,3 @@
+module ScormCloud
+  VERSION = "0.0.3"
+end

data/readme.textile

@@ -0,0 +1,53 @@
+h1. Rustici SCORM Cloud Ruby Client
+
+This ruby gem is provides a ruby interface to the Rustici Scorm Cloud.
+
+h2. Shell CLI Interface
+
+$ gem install 'scorm_cloud'
+$ scorm_cloud rustici.course.getCourseList --appid myappid --secret mysecret
+
+h2. Standard Ruby Use
+
+bc. require 'scorm_cloud'
+sc = ScormCloud::ScormCloud.new("my_app_id","my_secret_key")
+sc.course.get_course_list.each { |c| puts "#{c.id} #{c.title}"}
+
+h2. Ruby on Rails Use
+
+_Place the following in: Gemfile_
+
+bc. require 'scorm_cloud', :git => 'git@github.com:aeseducation/scorm-cloud.git'
+
+_Place the following in: config/initializers/scorm_cloud.rb_
+
+bc. # Change MyApplication to the name of your application
+MyApplication::Application.configure do |config|
+	config.scorm_cloud.appid = "my_app_id"
+	config.scorm_cloud.secretkey = "my_secret_key"
+end
+
+_Place the following in: /app/controllers.course_controller.rb_
+
+bc. # app/controllers/course_controller.rb
+class CourseController < ApplicationController
+	def index
+		@courses = scorm_cloud.course.get_course_list
+	end
+	def launch
+		return_url = course_index_url
+		reg = scorm_cloud.registrations.create_registration(...)
+		redirect_to scorm_cloud.registrations.launch(...)
+	end
+end
+
+_Place the following in: /app/views/course/index.html.erb_
+
+bq. # app/views/course/index.html.erb
+&lt;ul&gt;
+&lt;%= @courses.each |course| %&gt;
+&nbsp;&nbsp;&nbsp;&nbsp;&lt;li&gt;
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&lt;%= link_to course_launch_path(course.title,course.id) %&gt;
+&nbsp;&nbsp;&nbsp;&nbsp;&lt;/li&gt;
+&lt;% end %&gt;
+&lt;/ul&gt;