strongmind-agilix-buzz-client 0.8.3

data/lib/agilix/buzz/commands/enrollment.rb

@@ -0,0 +1,140 @@
+module Agilix
+  module Buzz
+    module Commands
+      module Enrollment
+
+        def enrollment_status
+          {
+            active: 1,
+            withdrawn: 4,
+            withdrawn_failed: 5,
+            transferred: 6,
+            completed: 7,
+            completed_no_credit: 8,
+            suspended: 9,
+            inactive: 10
+          }
+        end
+
+        def enrollment_status_lookup_value(int)
+          int = int.to_i
+          raise ArgumentError.new("Not a valid enrollment status code") unless enrollment_status.values.include?(int)
+          enrollment_status.find {|k,v| v == int}.first
+        end
+
+        # ISSUE: API format is very inconsistent on this one, requires both query string modification & body modification
+        # api.create_enrollments [{userid: 57026, entityid: 57025}]
+        def create_enrollments(items = [], disallowduplicates: false, disallowsamestatusduplicates: false )
+          options = items.map do |item|
+            item[:status] ||= 1
+            argument_cleaner(required_params: %i( userid entityid status ), optional_params: %i( roleid flags domainid startdate enddate reference schema data ), options: item )
+          end
+          if [disallowduplicates, disallowsamestatusduplicates].compact.any?
+            query_params = {}
+            query_params[:disallowduplicates] = disallowduplicates
+            query_params[:disallowsamestatusduplicates] = disallowsamestatusduplicates
+          end
+          authenticated_bulk_post cmd: "createenrollments", root_node: 'enrollment', query_params: query_params, body: options
+        end
+
+        # ISSUE: Inconsistent from other delete apis. many are singular, not plural
+        # api.delete_enrollments [ { enrollmentid: 60997 }]
+        def delete_enrollments(items = {})
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( enrollmentid ), optional_params: %i( ), options: item )
+          end
+          authenticated_bulk_post cmd: "deleteenrollments", root_node: 'enrollment', body: options
+        end
+
+        # api.get_enrollment enrollmentid: 60997
+        def get_enrollment3(options = {})
+          options = argument_cleaner(required_params: %i( enrollmentid ), optional_params: %i( select ), options: options )
+          authenticated_get cmd: "getenrollment3", **options
+        end
+        alias_method :get_enrollment, :get_enrollment3
+
+        # api.get_enrollment_activity enrollmentid: 60997
+        def get_enrollment_activity(options = {})
+          options = argument_cleaner(required_params: %i( enrollmentid ), optional_params: %i( last mergeoverlap ), options: options )
+          authenticated_get cmd: "getenrollmentactivity", **options
+        end
+
+        # api.get_enrollment_gradebook enrollmentid: 60997
+        def get_enrollment_gradebook2(options = {})
+          options = argument_cleaner(required_params: %i( enrollmentid ), optional_params: %i( forcerequireditems gradingschemeid gradingscheme itemid scorm zerounscored ), options: options )
+          authenticated_get cmd: "getenrollmentgradebook2", **options
+        end
+        alias_method :get_enrollment_gradebook, :get_enrollment_gradebook2
+
+        # api.get_enrollment_group_list enrollmentid: 60997
+        def get_enrollment_group_list(options = {})
+          options = argument_cleaner(required_params: %i( enrollmentid ), optional_params: %i( setid ), options: options )
+          authenticated_get cmd: "getenrollmentgrouplist", **options
+        end
+
+        # api.get_enrollment_metrics_report entityid: 50725, report: "Student"
+        # api.get_enrollment_metrics_report entityid: 50725, report: "Enrollment"
+        def get_enrollment_metrics_report(options = {})
+          raise ArgumentError.new("report can only be Student or Enrollment") unless ['Student', 'Enrollment'].include?(options[:report])
+          default_select = %w( user.id user.firstname user.lastname user.username user.reference)
+          student_select = %w( coursecount latecount failedcount paceyellows pacereds performanceyellows performancereds)
+          enrollment_select = %w(enrollment.id course.title course.id course.reference score achieved possible failing seconds completable completed gradable completedgradable graded percentcomplete late failed recentlyfailed pacelight pacereason performancelight performancereason lastduedatemissed calculateddate )
+          if options[:report] == "Student"
+            options[:select] ||= (default_select + student_select).flatten.join(",")
+          elsif options[:report] == "Enrollment"
+            options[:select] ||= (default_select + enrollment_select).flatten.join(",")
+          end
+          options = argument_cleaner(required_params: %i( entityid report select  ), optional_params: %i( filename format ), options: options )
+          authenticated_get cmd: "getenrollmentmetricsreport", **options
+        end
+
+        # api.list_enrollments domainid: 50725
+        def list_enrollments(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( includedescendantdomains limit show select query userdomainid userquery usertext coursedomainid coursequery coursetext ), options: options )
+          authenticated_get cmd: "listenrollments", **options
+        end
+
+        # api.list_enrollments_by_teacher teacheruserid: 50726
+        # api.list_enrollments_by_teacher
+        def list_enrollments_by_teacher(options = {})
+          options = argument_cleaner(required_params: %i(  ), optional_params: %i( teacheruserid teacherallstatus teacherdaysactivepastend privileges allstatus daysactivepastend userid select ), options: options )
+          authenticated_get cmd: "listenrollmentsbyteacher", **options
+        end
+
+        # api.list_entity_enrollments entityid: 60982
+        def list_entity_enrollments(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( privileges allstatus daysactivepastend userid select ), options: options )
+          authenticated_get cmd: "listentityenrollments", **options
+        end
+
+        # api.list_user_enrollments userid: 57181
+        def list_user_enrollments(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( allstatus entityid privileges daysactivepastend query select ), options: options )
+          authenticated_get cmd: "listuserenrollments", **options
+        end
+
+        # ISSUE: this should be a post, not a get
+        # api.put_self_assessment enrollmentid: 60997, understanding: 200, effort: 220, interest: 100
+        def put_self_assessment(options = {})
+          options = argument_cleaner(required_params: %i( enrollmentid ), optional_params: %i( understanding interest effort ), options: options )
+          authenticated_get cmd: "putselfassessment", **options
+        end
+
+        # api.restore_enrollment enrollmentid: 60997
+        def restore_enrollment(options = {})
+          options = argument_cleaner(required_params: %i( enrollmentid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "restoreenrollment", **options
+        end
+
+        # api.update_enrollments [{enrollmentid: 60997, status: 7}]
+        def update_enrollments(items)
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( enrollmentid ), optional_params: %i( userid entityid domainid roleid flags status startdate enddate reference schema data ), options: item)
+          end
+          authenticated_bulk_post cmd: "updateenrollments", root_node: 'enrollment', body: options
+        end
+
+      end
+    end
+  end
+end

data/lib/agilix/buzz/commands/general.rb

@@ -0,0 +1,70 @@
+module Agilix
+  module Buzz
+    module Commands
+      module General
+
+        # api.echo test: 'param'
+        def echo(options= {})
+          post cmd: "echo", **options
+        end
+
+        # api.get_command_list
+        def get_command_list
+          get cmd: "getcommandlist"
+        end
+
+        # ISSUE: nothing saying this is an authenticated call, when others are non-authenticated
+        # api.get_entity_type entityid: 57025
+        def get_entity_type(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( select ), options: options )
+          authenticated_get cmd: "getentitytype", **options
+        end
+
+        # ISSUE: docs in getting started reference a `level` param, actual docs suggest using rating
+        # api.get_status rating: 4, html: true, sms: true
+        def get_status(options = {})
+          options = argument_cleaner(required_params: %i(  ), optional_params: %i( rating sms html ), options: options )
+          authenticated_get cmd: "getstatus", **options
+        end
+
+        # this is a non-authenticated call
+        # api.get_status
+        def get_basic_status(options = {})
+          options = argument_cleaner(required_params: %i(  ), optional_params: %i( rating sms html ), options: options )
+          get cmd: "getstatus", **options
+        end
+
+        # ISSUE: Docs have cmd spelled wrong, this API doesn't seem to work at all AccessDenied. It did say experimental
+        # api.get_upload_limits
+        # api.get_upload_limits domainid: 57025
+        def get_upload_limits(options = {})
+          options = argument_cleaner(required_params: %i(  ), optional_params: %i( userid domainid ), options: options )
+          get cmd: "getuploadlimits", **options
+        end
+
+        # api.send_mail subject: "Test email", body: "Did you get this?", enrollmentid: 60997, enrollment_ids: ["all"]
+        def send_mail(options = {})
+          options = argument_cleaner(required_params: %i( subject body enrollmentid enrollment_ids ), optional_params: %i( groups roles strings), options: options )
+          request = {email: {
+            subject: {"$value" => options[:subject]},
+            body: {"$value" => options[:body]},
+            enrollments: {enrollment: options[:enrollment_ids].map {|id| {id: id} } }
+          }}
+          request[:email][:groups] = {group: options[:groups].map {|id| {id: id} } } if options[:groups]
+          request[:email][:roles] = {role: options[:roles].map {|id| {id: id} } } if options[:roles]
+          if options[:strings]
+            request[:email][:strings] = options[:strings].map do |k,v|
+              [ k , {"$value" => v } ]
+            end.to_h
+          end
+          enrollment_response = self.get_enrollment enrollmentid: options[:enrollmentid]
+          user_id = enrollment_response.dig("response", "enrollment", "userid")
+          proxy_api = self.proxy_api userid: user_id
+          proxy_api.authenticated_query_post query_params: {cmd: "sendmail", enrollmentid: options[:enrollmentid] },  **request
+        end
+
+
+      end
+    end
+  end
+end

data/lib/agilix/buzz/commands/library.rb

@@ -0,0 +1,43 @@
+module Agilix
+  module Buzz
+    module Commands
+      module Library
+
+        # api.get_library_page domainid: 57031, pageid: "230433194a1e4699bfa576aa6e6743c6"
+        def get_library_page(options = {})
+          options = argument_cleaner(required_params: %i( domainid pageid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getlibrarypage", **options
+        end
+
+        # api.list_library_pages domainid: 57031
+        def list_library_pages(options = {})
+          options = argument_cleaner(required_params: %i(  domainid ), optional_params: %i( libraryid limit select ), options: options )
+          authenticated_get cmd: "listlibrarypages", **options
+        end
+
+        # api.create_library_page domainid: 57031, libraryid: 'testlib', title: "Greatest ever", description: "This really is the best", body: "<h1>Check it out!</h1><iframe src='https://www.google.com'></iframe>"
+        def create_library_page(options = {})
+          optional_params = argument_cleaner(required_params: %i( domainid libraryid title description  ), optional_params: %i( body id name 'meta-featured' 'meta-type' 'meta-category' ), options: options )
+          # authenticated_query_post cmd: "putresource", **options
+          authenticated_post cmd: "createlibrarypage", **options
+        end
+
+        # # api.search_library_pages domainid: 57031, path: "banner.css"
+        # def search_library_pages(options = {})
+        #   options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( libraryid limit select q ), options: options )
+        #   authenticated_get cmd: "searchlibrarypages", **options
+        # end
+
+      end
+    end
+  end
+end
+
+# createlibrarypagebookmark
+# deletelibrarypage
+# deletelibrarypagebookmark
+# listlibrarypagebookmarks
+# populatelibrarypageedits
+# populatelibrarypageedits
+# reindexlibrarypages
+# updatelibrarypage

data/lib/agilix/buzz/commands/report.rb

@@ -0,0 +1,37 @@
+module Agilix
+  module Buzz
+    module Commands
+      module Report
+
+        # Use this one to find reports you can run
+        # api.get_runnable_report_list domainid: 57025
+        def get_runnable_report_list(options = {})
+          options = argument_cleaner(required_params: %i( ), optional_params: %i( entityid domainid ), options: options )
+          authenticated_get cmd: "getrunnablereportlist", **options
+        end
+
+        # Use this one to run a report
+        # api.run_report reportid: 127, entityid: 57025
+        def run_report(options = {})
+          options = argument_cleaner(required_params: %i( reportid entityid ), optional_params: %i( format content_disposition nodata AsOf), options: options )
+          authenticated_get cmd: "runreport", **options
+        end
+
+        # slightly more info than get_runnable_report_list
+        # api.get_report_info reportid: 123
+        def get_report_info(options = {})
+          options = argument_cleaner(required_params: %i( reportid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getreportinfo", **options
+        end
+
+        # This call seems worthless, and we don't seem to have rights
+        # api.get_report_list domainid: 1
+        def get_report_list(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getreportlist", **options
+        end
+
+      end
+    end
+  end
+end

data/lib/agilix/buzz/commands/resource.rb

@@ -0,0 +1,124 @@
+  module Agilix
+  module Buzz
+    module Commands
+      module Resource
+
+        # api.copy_resources [ {sourceentityid: 57025, destinationentityid: 57031, sourcepath: "banner.css" }]
+        def copy_resources(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( sourceentityid destinationentityid ), optional_params: %i( sourcepath destinationpath ), options: item )
+          end
+          authenticated_bulk_post cmd: "copyresources", root_node: "resource", body: options
+        end
+
+        # api.delete_resources [{entityid: 57031, path: 'banner.css'}]
+        def delete_resources(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( entityid path ), optional_params: %i( class ), options: item )
+          end
+          authenticated_bulk_post cmd: "deleteresources", root_node: "resource", body: options
+        end
+
+        # api.get_entity_resource_id entityid: 57025
+        def get_entity_resource_id(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getentityresourceid", **options
+        end
+
+        # api.get_resource entityid: 57031, path: "banner.css"
+        def get_resource(options = {})
+          options = argument_cleaner(required_params: %i( entityid path ), optional_params: %i( version packagetype attachment class ), options: options )
+          authenticated_get cmd: "getresource", **options
+        end
+
+        # ISSUE: This is a get request with a POST verb. The documentation only suggests getting a single resoure, so I'm not sure why it would be a bulk post syntax. it does seem to respond to multiple resources though,so we'll adapt
+        # api.get_resource_info  [{entityid: 57031, path: "banner.css"}]
+        def get_resource_info2(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( entityid path ), optional_params: %i( class ), options: item )
+          end
+          authenticated_bulk_post cmd: "getresourceinfo2", root_node: "resource", body: options
+        end
+        alias_method :get_resource_info, :get_resource_info2
+
+        # api.get_resource_list2 entityid: 57025
+        def get_resource_list2(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( path recurse query allversions entries class ), options: options )
+          authenticated_get cmd: "getresourcelist2", **options
+        end
+        alias_method :get_resource_list, :get_resource_list2
+
+        # api.list_restorable_resources entityid: 57025
+        def list_restorable_resources(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "listrestorableresources", **options
+        end
+
+        # file_name = "my-file.pdf"
+        # file = File.open file_name
+        # api.put_resource file, {entityid: 57025, path: file_name}
+        def put_resource(file, options = {})
+          options = argument_cleaner(required_params: %i( entityid path ), optional_params: %i( status class drophistory contenttype ), options: options )
+          # authenticated_query_post cmd: "putresource", **options
+          authenticated_query_post query_params: {cmd: "putresource", **options }, file: file
+        end
+
+        # api.put_resource_folders [{entityid: 57031, path: 'test/folder-1'}]
+        def put_resource_folders(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( entityid path ), optional_params: %i( ), options: item )
+          end
+          authenticated_bulk_post cmd: "putresourcefolders", root_node: "folder", body: options
+        end
+
+        # api.restore_resources [{entityid: 57031, path: 'banner.css'}]
+        def restore_resources(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( entityid path ), optional_params: %i( class ), options: item )
+          end
+          authenticated_bulk_post cmd: "restoreresources", root_node: "resource", body: options
+        end
+
+        # api.delete_documents
+        def delete_documents(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( enrollmentid itemid path ), optional_params: %i( ), options: item )
+          end
+          authenticated_bulk_post cmd: "deletedocuments", root_node: "document", body: options
+        end
+
+        # api.get_document enrollmentid: 60997
+        def get_document(options = {})
+          options = argument_cleaner(required_params: %i( enrollmentid itemid path ), optional_params: %i( version ), options: options )
+          authenticated_get cmd: "getdocument", **options
+        end
+
+        # ISSUE: Why is get command a bulk POST request
+        # api.get_document_info
+        def get_document_info(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( enrollmentid itemid path ), optional_params: %i( ), options: item )
+          end
+          authenticated_bulk_post cmd: "getdocumentinfo", root_node: "document", body: options
+          authenticated_get cmd: "", **options
+        end
+
+        # api.list_restorable_documents enrollmentid: 64001
+        def list_restorable_documents(options = {})
+          options = argument_cleaner(required_params: %i( enrollmentid itemid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "listrestorabledocuments", **options
+        end
+
+
+        # api.restore_documents
+        def restore_documents(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i(  enrollmentid itemid path), optional_params: %i( version ), options: item )
+          end
+          authenticated_bulk_post cmd: "restoredocuments", root_node: "document", body: options
+        end
+
+      end
+    end
+  end
+end

data/lib/agilix/buzz/commands/right.rb

@@ -0,0 +1,234 @@
+module Agilix
+  module Buzz
+    module Commands
+      module Right
+
+        # ISSUE: Why is this create singular, not multiple?
+        # api.create_role domainid: 57025, name: "Test Role", privileges: api.right_flags[:create_domain]
+        def create_role(options = {})
+          options = argument_cleaner(required_params: %i( domainid name privileges ), optional_params: %i( reference entitytype ), options: options )
+          raise ArgumentError.new("Not a valid entitytype. Should be D,C, or empty") unless [nil, "", "D", "C"].include?(options[:entitytype])
+          authenticated_post cmd: "createrole", **options
+        end
+
+        # api.delete_role roleid: 61316
+        def delete_role(options = {})
+          options = argument_cleaner(required_params: %i( roleid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "deleterole", **options
+        end
+
+        # api.delete_subscriptions subscriberid: 57181, entityid: 57025
+        def delete_subscriptions(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( subscriberid entityid ), optional_params: %i( flags ), options: item )
+          end
+          authenticated_bulk_post cmd: "deletesubscriptions", root_node: 'subscription', body: options
+        end
+
+        # api.get_actor_rights actorid: 5000, entitytypes: "U|S|D"
+        def get_actor_rights(options = {})
+          options = argument_cleaner(required_params: %i( actorid ), optional_params: %i( entitytypes ), options: options )
+          authenticated_get cmd: "getactorrights", **options
+        end
+
+        # api.get_effective_rights entityid: 57025
+        def get_effective_rights(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "geteffectiverights", **options
+        end
+
+        # api.get_effective_subscription_list
+        def get_effective_subscription_list(options = {})
+          options = argument_cleaner(required_params: %i( ), optional_params: %i( select ), options: options )
+          authenticated_get cmd: "geteffectivesubscriptionlist", **options
+        end
+
+        # api.get_entity_rights entityid: 57025
+        def get_entity_rights(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getentityrights", **options
+        end
+
+        # api.get_entity_subscription_list entityid: 57025
+        def get_entity_subscription_list(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( subscriberid), options: options )
+          authenticated_get cmd: "getentitysubscriptionlist", **options
+        end
+
+        # api.get_personas userid: 57026
+        def get_personas(options = {})
+          options = argument_cleaner(required_params: %i( ), optional_params: %i( userid domainid ), options: options )
+          authenticated_get cmd: "getpersonas", **options
+        end
+
+        # api.get_rights actorid: 57026, entityid: 57025
+        def get_rights(options = {})
+          options = argument_cleaner(required_params: %i( actorid entityid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getrights", **options
+        end
+
+        # api.get_rights_list domainid: 57025
+        def get_rights_list(options = {})
+          options = argument_cleaner(required_params: %i(  ), optional_params: %i( domainid restrictdomain ), options: options )
+          authenticated_get cmd: "getrightslist", **options
+        end
+
+        # api.get_role roleid: 61316
+        def get_role(options = {})
+          options = argument_cleaner(required_params: %i( roleid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getrole", **options
+        end
+
+        # Get for a domain
+        # api.get_subscription_list subscriberid: 57025
+        # Get for a user
+        # api.get_subscription_list subscriberid: 57026
+        def get_subscription_list(options = {})
+          options = argument_cleaner(required_params: %i( subscriberid ), optional_params: %i( entityid ), options: options )
+          authenticated_get cmd: "getsubscriptionlist", **options
+        end
+
+        # api.list_roles domainid: 57025
+        def list_roles(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "listroles", **options
+        end
+
+        # api.restore_role roleid: 61316
+        def restore_role(options = {})
+          options = argument_cleaner(required_params: %i( roleid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "restorerole", **options
+        end
+
+        # api.update_rights [ {actorid: 57026, entityid: 57025, roleid: 61316}]
+        def update_rights(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( actorid entityid ), optional_params: %i( roleid flags schema ), options: item )
+          end
+          authenticated_bulk_post cmd: "updaterights", root_node: 'rights', body: options
+        end
+
+        # api.update_role roleid: 61316, name: "Test Role Updates", privileges: api.right_flags[:update_domain]
+        def update_role(options = {})
+          options = argument_cleaner(required_params: %i( roleid  ), optional_params: %i( name privileges reference entitytype ), options: options )
+          raise ArgumentError.new("Not a valid entitytype. Should be D,C, or empty") unless [nil, "", "D", "C"].include?(options[:entitytype])
+
+          authenticated_post cmd: "updaterole", **options
+        end
+
+        # ISSUE: Why is this root node singular?
+        # api.update_subscriptions subscriberid: 57181, entityid: 60982, startdate: "2019-03-15", enddate: "2019-03-15"
+        def update_subscriptions(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( subscriberid entityid startdate enddate ), optional_params: %i( subscriptionflags ), options: item )
+          end
+          authenticated_bulk_post cmd: "updatesubscriptions", root_node: 'subscription', body: options
+        end
+
+        def right_flags
+          {
+            admin: -1,
+            none: 0,
+            participate: 1,
+            create_domain: 16,
+            read_domain: 32,
+            update_domain: 64,
+            delete_domain: 128,
+            create_user: 256,
+            read_user: 512,
+            update_user: 1024,
+            delete_user: 2048,
+            create_course: 65536,
+            read_course: 131072,
+            update_course: 262144,
+            delete_course: 524288,
+            create_section: 1048576,
+            read_section: 2097152,
+            update_section: 4194304,
+            delete_section: 8388608,
+            grade_assignment: 16777216,
+            grade_forum: 33554432,
+            grade_exam: 67108864,
+            setup_gradebook: 134217728,
+            control_domain: 268435456,
+            control_course: 536870912,
+            control_section: 1073741824,
+            read_gradebook: 2147483648,
+            report_domain: 4294967296,
+            report_course: 8589934592,
+            report_section: 17179869184,
+            post_domain_announcements: 34359738368,
+            proxy: 68719476736,
+            report_user: 274877906944,
+            submit_final_grade: 549755813888,
+            control_enrollment: 1099511627776,
+            read_enrollment: 2199023255552,
+            read_course_full: 4398046511104,
+            control_user: 8796093022208,
+            read_objective: 17592186044416,
+            update_objective: 35184372088832
+          }
+        end
+
+        def right_flags_hex
+          {
+            admin: "-0x01",
+            none: "0x00",
+            participate: "0x01",
+            create_domain: "0x10",
+            read_domain: "0x20",
+            update_domain: "0x40",
+            delete_domain: "0x80",
+            create_user: "0x100",
+            read_user: "0x200",
+            update_user: "0x400",
+            delete_user: "0x800",
+            create_course: "0x10000",
+            read_course: "0x20000",
+            update_course: "0x40000",
+            delete_course: "0x80000",
+            create_section: "0x100000",
+            read_section: "0x200000",
+            update_section: "0x400000",
+            delete_section: "0x800000",
+            grade_assignment: "0x1000000",
+            grade_forum: "0x2000000",
+            grade_exam: "0x4000000",
+            setup_gradebook: "0x8000000",
+            control_domain: "0x10000000",
+            control_course: "0x20000000",
+            control_section: "0x40000000",
+            read_gradebook: "0x80000000",
+            report_domain: "0x100000000",
+            report_course: "0x200000000",
+            report_section: "0x400000000",
+            post_domain_announcements: "0x800000000",
+            proxy: "0x1000000000",
+            report_user: "0x4000000000",
+            submit_final_grade: "0x8000000000",
+            control_enrollment: "0x10000000000",
+            read_enrollment: "0x20000000000",
+            read_course_full: "0x40000000000",
+            control_user: "0x80000000000",
+            read_objective: "0x100000000000",
+            update_objective: "0x200000000000"
+          }
+        end
+
+
+        def right_flags_lookup_value(val)
+          val = val.to_s
+          if val.include?("x")
+            raise ArgumentError.new("Not a valid right flag") unless right_flags_hex.values.include?(val)
+            right_flags_hex.find {|k,v| v == val}.first
+          else
+            val = val.to_i
+            raise ArgumentError.new("Not a valid right flag") unless right_flags.values.include?(val)
+            right_flags.find {|k,v| v == val}.first
+          end
+        end
+
+      end
+    end
+  end
+end