class Pandarus::V1

Public Instance Methods

abort_all_pending_sis_imports(account_id,opts={}) click to toggle source

Abort all pending SIS imports

# File lib/pandarus/v1_api.rb, line 23296
def abort_all_pending_sis_imports(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sis_imports/abort_all_pending",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  boolean.new(response)
  

end
abort_generation_of_report_or_remove_previously_generated_one(course_id,quiz_id,id,opts={}) click to toggle source

Abort the generation of a report, or remove a previously generated one

# File lib/pandarus/v1_api.rb, line 21787
def abort_generation_of_report_or_remove_previously_generated_one(course_id,quiz_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/reports/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
abort_sis_import(account_id,id,opts={}) click to toggle source

Abort SIS import

# File lib/pandarus/v1_api.rb, line 23259
def abort_sis_import(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sis_imports/{id}/abort",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  SisImport.new(response)
  

end
activate_role(account_id,id,role_id,opts={}) click to toggle source

Activate a role

# File lib/pandarus/v1_api.rb, line 22915
def activate_role(account_id,id,role_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :role_id,
    :role,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  raise "role_id is required" if role_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id,
    :role_id => role_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/roles/{id}/activate",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Role.new(response)
  

end
activity_stream_summary(opts={}) click to toggle source

Activity stream summary

# File lib/pandarus/v1_api.rb, line 25335
def activity_stream_summary(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/activity_stream/summary",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
add_authentication_provider(account_id,opts={}) click to toggle source

Add authentication provider

# File lib/pandarus/v1_api.rb, line 2910
def add_authentication_provider(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/authentication_providers",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  AuthenticationProvider.new(response)
  

end
add_course_to_favorites(id,opts={}) click to toggle source

Add course to favorites

# File lib/pandarus/v1_api.rb, line 11117
def add_course_to_favorites(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/self/favorites/courses/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Favorite.new(response)
  

end
add_group_to_favorites(id,opts={}) click to toggle source

Add group to favorites

# File lib/pandarus/v1_api.rb, line 11151
def add_group_to_favorites(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/self/favorites/groups/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Favorite.new(response)
  

end
add_message(id,body,opts={}) click to toggle source

Add a message

# File lib/pandarus/v1_api.rb, line 6610
def add_message(id,body,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :body,
    :attachment_ids,
    :media_comment_id,
    :media_comment_type,
    :recipients,
    :included_messages,
    :user_note,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "body is required" if body.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :body => body

  )

  # resource path
  path = path_replace("/v1/conversations/{id}/add_message",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
add_observee(user_id,observee_id,opts={}) click to toggle source

Add an observee

# File lib/pandarus/v1_api.rb, line 25160
def add_observee(user_id,observee_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "observee_id is required" if observee_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :observee_id => observee_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/observees/{observee_id}",
    :user_id => user_id,
    :observee_id => observee_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  User.new(response)
  

end
add_observee_with_credentials(user_id,opts={}) click to toggle source

Add an observee with credentials

# File lib/pandarus/v1_api.rb, line 25086
def add_observee_with_credentials(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :observee__unique_id__,
    :observee__password__,
    :access_token,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/observees",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  User.new(response)
  

end
add_recipients(id,recipients,opts={}) click to toggle source

Add recipients

# File lib/pandarus/v1_api.rb, line 6573
def add_recipients(id,recipients,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :recipients,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "recipients is required" if recipients.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :recipients => recipients

  )

  # resource path
  path = path_replace("/v1/conversations/{id}/add_recipients",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
answering_questions(quiz_submission_id,attempt,validation_token,opts={}) click to toggle source

Answering questions

# File lib/pandarus/v1_api.rb, line 22020
def answering_questions(quiz_submission_id,attempt,validation_token,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :attempt,
    :validation_token,
    :access_code,
    :quiz_questions,
    

  ]

  # verify existence of params
  raise "quiz_submission_id is required" if quiz_submission_id.nil?
  raise "attempt is required" if attempt.nil?
  raise "validation_token is required" if validation_token.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :quiz_submission_id => quiz_submission_id,
    :attempt => attempt,
    :validation_token => validation_token

  )

  # resource path
  path = path_replace("/v1/quiz_submissions/{quiz_submission_id}/questions",
    :quiz_submission_id => quiz_submission_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, QuizSubmissionQuestion, path, query_params)
  

end
assign_unassigned_members(group_category_id,opts={}) click to toggle source

Assign unassigned members

# File lib/pandarus/v1_api.rb, line 14597
def assign_unassigned_members(group_category_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :sync,
    

  ]

  # verify existence of params
  raise "group_category_id is required" if group_category_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_category_id => group_category_id

  )

  # resource path
  path = path_replace("/v1/group_categories/{group_category_id}/assign_unassigned_members",
    :group_category_id => group_category_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  GroupMembership | Progress.new(response)
  

end
batch_create_overrides_in_course(course_id,assignment_overrides,opts={}) click to toggle source

Batch create overrides in a course

# File lib/pandarus/v1_api.rb, line 2805
def batch_create_overrides_in_course(course_id,assignment_overrides,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :assignment_overrides,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_overrides is required" if assignment_overrides.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_overrides => assignment_overrides

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/overrides",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, AssignmentOverride, path, query_params)
  

end
batch_retrieve_overrides_in_course(course_id,assignment_overrides__id__,assignment_overrides__assignment_id__,opts={}) click to toggle source

Batch retrieve overrides in a course

# File lib/pandarus/v1_api.rb, line 2767
def batch_retrieve_overrides_in_course(course_id,assignment_overrides__id__,assignment_overrides__assignment_id__,opts={})
  query_param_keys = [
    :assignment_overrides__id__,
    :assignment_overrides__assignment_id__

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_overrides__id__ is required" if assignment_overrides__id__.nil?
  raise "assignment_overrides__assignment_id__ is required" if assignment_overrides__assignment_id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_overrides__id__ => assignment_overrides__id__,
    :assignment_overrides__assignment_id__ => assignment_overrides__assignment_id__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/overrides",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, AssignmentOverride, path, query_params)
  

end
batch_update_conversations(conversation_ids,event,opts={}) click to toggle source

Batch update conversations

# File lib/pandarus/v1_api.rb, line 6690
def batch_update_conversations(conversation_ids,event,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :conversation_ids,
    :event,
    

  ]

  # verify existence of params
  raise "conversation_ids is required" if conversation_ids.nil?
  raise "event is required" if event.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :conversation_ids => conversation_ids,
    :event => event

  )

  # resource path
  path = path_replace("/v1/conversations",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Progress.new(response)
  

end
batch_update_overrides_in_course(course_id,assignment_overrides,opts={}) click to toggle source

Batch update overrides in a course

# File lib/pandarus/v1_api.rb, line 2841
def batch_update_overrides_in_course(course_id,assignment_overrides,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :assignment_overrides,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_overrides is required" if assignment_overrides.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_overrides => assignment_overrides

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/overrides",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, AssignmentOverride, path, query_params)
  

end
begin_migration_to_push_to_associated_courses(course_id,template_id,opts={}) click to toggle source

Begin a migration to push to associated courses

# File lib/pandarus/v1_api.rb, line 3340
def begin_migration_to_push_to_associated_courses(course_id,template_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :comment,
    :send_notification,
    :copy_settings,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}/migrations",
    :course_id => course_id,
    :template_id => template_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  BlueprintMigration.new(response)
  

end
clear_course_nicknames(opts={}) click to toggle source

Clear course nicknames

# File lib/pandarus/v1_api.rb, line 26423
def clear_course_nicknames(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/course_nicknames",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
close_notification_for_user(account_id,user_id,id,opts={}) click to toggle source

Close notification for user

# File lib/pandarus/v1_api.rb, line 125
def close_notification_for_user(account_id,user_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/users/{user_id}/account_notifications/{id}",
    :account_id => account_id,
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  AccountNotification.new(response)
  

end
close_opened_poll_session(poll_id,id,opts={}) click to toggle source

Close an opened poll session

# File lib/pandarus/v1_api.rb, line 20548
def close_opened_poll_session(poll_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions/{id}/close",
    :poll_id => poll_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
complete_quiz_submission_turn_it_in(course_id,quiz_id,id,attempt,validation_token,opts={}) click to toggle source

Complete the quiz submission (turn it in).

# File lib/pandarus/v1_api.rb, line 22385
def complete_quiz_submission_turn_it_in(course_id,quiz_id,id,attempt,validation_token,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :attempt,
    :validation_token,
    :access_code,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  raise "attempt is required" if attempt.nil?
  raise "validation_token is required" if validation_token.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id,
    :attempt => attempt,
    :validation_token => validation_token

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions/{id}/complete",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
conclude_deactivate_or_delete_enrollment(course_id,id,opts={}) click to toggle source

Conclude, deactivate, or delete an enrollment

# File lib/pandarus/v1_api.rb, line 10334
def conclude_deactivate_or_delete_enrollment(course_id,id,opts={})
  query_param_keys = [
    :task

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/enrollments/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Enrollment.new(response)
  

end
copy_course_content(course_id,opts={}) click to toggle source

Copy course content

# File lib/pandarus/v1_api.rb, line 7794
def copy_course_content(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :source_course,
    :except,
    :only,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/course_copy",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
copy_file(dest_folder_id,source_file_id,opts={}) click to toggle source

Copy a file

# File lib/pandarus/v1_api.rb, line 13124
def copy_file(dest_folder_id,source_file_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :source_file_id,
    :on_duplicate,
    

  ]

  # verify existence of params
  raise "dest_folder_id is required" if dest_folder_id.nil?
  raise "source_file_id is required" if source_file_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :dest_folder_id => dest_folder_id,
    :source_file_id => source_file_id

  )

  # resource path
  path = path_replace("/v1/folders/{dest_folder_id}/copy_file",
    :dest_folder_id => dest_folder_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  File.new(response)
  

end
copy_folder(dest_folder_id,source_folder_id,opts={}) click to toggle source

Copy a folder

# File lib/pandarus/v1_api.rb, line 13162
def copy_folder(dest_folder_id,source_folder_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :source_folder_id,
    

  ]

  # verify existence of params
  raise "dest_folder_id is required" if dest_folder_id.nil?
  raise "source_folder_id is required" if source_folder_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :dest_folder_id => dest_folder_id,
    :source_folder_id => source_folder_id

  )

  # resource path
  path = path_replace("/v1/folders/{dest_folder_id}/copy_folder",
    :dest_folder_id => dest_folder_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Folder.new(response)
  

end
copy_provisional_grade(course_id,assignment_id,provisional_grade_id,opts={}) click to toggle source

Copy provisional grade

# File lib/pandarus/v1_api.rb, line 16087
def copy_provisional_grade(course_id,assignment_id,provisional_grade_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "provisional_grade_id is required" if provisional_grade_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :provisional_grade_id => provisional_grade_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/provisional_grades/{provisional_grade_id}/copy_to_final_mark",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :provisional_grade_id => provisional_grade_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ProvisionalGrade.new(response)
  

end
course_activity_stream(course_id,opts={}) click to toggle source

Course activity stream

# File lib/pandarus/v1_api.rb, line 7257
def course_activity_stream(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/activity_stream",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
course_activity_stream_summary(course_id,opts={}) click to toggle source

Course activity stream summary

# File lib/pandarus/v1_api.rb, line 7291
def course_activity_stream_summary(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/activity_stream/summary",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
course_todo_items(course_id,opts={}) click to toggle source

Course TODO items

# File lib/pandarus/v1_api.rb, line 7325
def course_todo_items(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/todo",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
create_appointment_group(appointment_group__context_codes__,appointment_group__title__,opts={}) click to toggle source

Create an appointment group

# File lib/pandarus/v1_api.rb, line 1751
def create_appointment_group(appointment_group__context_codes__,appointment_group__title__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :appointment_group__context_codes__,
    :appointment_group__sub_context_codes__,
    :appointment_group__title__,
    :appointment_group__description__,
    :appointment_group__location_name__,
    :appointment_group__location_address__,
    :appointment_group__publish__,
    :appointment_group__participants_per_appointment__,
    :appointment_group__min_appointments_per_participant__,
    :appointment_group__max_appointments_per_participant__,
    :appointment_group__new_appointments_____x__,
    :appointment_group__participant_visibility__,
    

  ]

  # verify existence of params
  raise "appointment_group__context_codes__ is required" if appointment_group__context_codes__.nil?
  raise "appointment_group__title__ is required" if appointment_group__title__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :appointment_group__context_codes__ => appointment_group__context_codes__,
    :appointment_group__title__ => appointment_group__title__

  )

  # resource path
  path = path_replace("/v1/appointment_groups",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_assignment(course_id,assignment__name__,opts={}) click to toggle source

Create an assignment

# File lib/pandarus/v1_api.rb, line 2358
def create_assignment(course_id,assignment__name__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :assignment__name__,
    :assignment__position__,
    :assignment__submission_types__,
    :assignment__allowed_extensions__,
    :assignment__turnitin_enabled__,
    :assignment__vericite_enabled__,
    :assignment__turnitin_settings__,
    :assignment__integration_data__,
    :assignment__integration_id__,
    :assignment__peer_reviews__,
    :assignment__automatic_peer_reviews__,
    :assignment__notify_of_update__,
    :assignment__group_category_id__,
    :assignment__grade_group_students_individually__,
    :assignment__external_tool_tag_attributes__,
    :assignment__points_possible__,
    :assignment__grading_type__,
    :assignment__due_at__,
    :assignment__lock_at__,
    :assignment__unlock_at__,
    :assignment__description__,
    :assignment__assignment_group_id__,
    :assignment__muted__,
    :assignment__assignment_overrides__,
    :assignment__only_visible_to_overrides__,
    :assignment__published__,
    :assignment__grading_standard_id__,
    :assignment__omit_from_final_grade__,
    :assignment__quiz_lti__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment__name__ is required" if assignment__name__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment__name__ => assignment__name__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Assignment.new(response)
  

end
create_assignment_group(course_id,opts={}) click to toggle source

Create an Assignment Group

# File lib/pandarus/v1_api.rb, line 2091
def create_assignment_group(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :position,
    :group_weight,
    :sis_source_id,
    :integration_data,
    :rules,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignment_groups",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  AssignmentGroup.new(response)
  

end
create_assignment_override(course_id,assignment_id,opts={}) click to toggle source

Create an assignment override

# File lib/pandarus/v1_api.rb, line 2638
def create_assignment_override(course_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :assignment_override__student_ids__,
    :assignment_override__title__,
    :assignment_override__group_id__,
    :assignment_override__course_section_id__,
    :assignment_override__due_at__,
    :assignment_override__unlock_at__,
    :assignment_override__lock_at__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/overrides",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  AssignmentOverride.new(response)
  

end
create_bookmark(opts={}) click to toggle source

Create bookmark

# File lib/pandarus/v1_api.rb, line 3719
def create_bookmark(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :url,
    :position,
    :data,
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/bookmarks",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Bookmark.new(response)
  

end
create_calendar_event(calendar_event__context_code__,opts={}) click to toggle source

Create a calendar event

# File lib/pandarus/v1_api.rb, line 3972
def create_calendar_event(calendar_event__context_code__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :calendar_event__context_code__,
    :calendar_event__title__,
    :calendar_event__description__,
    :calendar_event__start_at__,
    :calendar_event__end_at__,
    :calendar_event__location_name__,
    :calendar_event__location_address__,
    :calendar_event__time_zone_edited__,
    :calendar_event__child_event_data_____x____start_at__,
    :calendar_event__child_event_data_____x____end_at__,
    :calendar_event__child_event_data_____x____context_code__,
    :calendar_event__duplicate____count__,
    :calendar_event__duplicate____interval__,
    :calendar_event__duplicate____frequency__,
    :calendar_event__duplicate____append_iterator__,
    

  ]

  # verify existence of params
  raise "calendar_event__context_code__ is required" if calendar_event__context_code__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :calendar_event__context_code__ => calendar_event__context_code__

  )

  # resource path
  path = path_replace("/v1/calendar_events",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_communication_channel(user_id,communication_channel__address__,communication_channel__type__,opts={}) click to toggle source

Create a communication channel

# File lib/pandarus/v1_api.rb, line 4556
def create_communication_channel(user_id,communication_channel__address__,communication_channel__type__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :communication_channel__address__,
    :communication_channel__type__,
    :communication_channel__token__,
    :skip_confirmation,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "communication_channel__address__ is required" if communication_channel__address__.nil?
  raise "communication_channel__type__ is required" if communication_channel__type__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :communication_channel__address__ => communication_channel__address__,
    :communication_channel__type__ => communication_channel__type__

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  CommunicationChannel.new(response)
  

end
create_content_migration_accounts(account_id,migration_type,opts={}) click to toggle source

Create a content migration

# File lib/pandarus/v1_api.rb, line 5821
def create_content_migration_accounts(account_id,migration_type,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :migration_type,
    :pre_attachment__name__,
    :pre_attachment__x__,
    :settings__file_url__,
    :settings__source_course_id__,
    :settings__folder_id__,
    :settings__overwrite_quizzes__,
    :settings__question_bank_id__,
    :settings__question_bank_name__,
    :date_shift_options__shift_dates__,
    :date_shift_options__old_start_date__,
    :date_shift_options__old_end_date__,
    :date_shift_options__new_start_date__,
    :date_shift_options__new_end_date__,
    :date_shift_options__day_substitutions_____x__,
    :date_shift_options__remove_dates__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "migration_type is required" if migration_type.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :migration_type => migration_type

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/content_migrations",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
create_content_migration_courses(course_id,migration_type,opts={}) click to toggle source

Create a content migration

# File lib/pandarus/v1_api.rb, line 5873
def create_content_migration_courses(course_id,migration_type,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :migration_type,
    :pre_attachment__name__,
    :pre_attachment__x__,
    :settings__file_url__,
    :settings__source_course_id__,
    :settings__folder_id__,
    :settings__overwrite_quizzes__,
    :settings__question_bank_id__,
    :settings__question_bank_name__,
    :date_shift_options__shift_dates__,
    :date_shift_options__old_start_date__,
    :date_shift_options__old_end_date__,
    :date_shift_options__new_start_date__,
    :date_shift_options__new_end_date__,
    :date_shift_options__day_substitutions_____x__,
    :date_shift_options__remove_dates__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "migration_type is required" if migration_type.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :migration_type => migration_type

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_migrations",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
create_content_migration_groups(group_id,migration_type,opts={}) click to toggle source

Create a content migration

# File lib/pandarus/v1_api.rb, line 5925
def create_content_migration_groups(group_id,migration_type,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :migration_type,
    :pre_attachment__name__,
    :pre_attachment__x__,
    :settings__file_url__,
    :settings__source_course_id__,
    :settings__folder_id__,
    :settings__overwrite_quizzes__,
    :settings__question_bank_id__,
    :settings__question_bank_name__,
    :date_shift_options__shift_dates__,
    :date_shift_options__old_start_date__,
    :date_shift_options__old_end_date__,
    :date_shift_options__new_start_date__,
    :date_shift_options__new_end_date__,
    :date_shift_options__day_substitutions_____x__,
    :date_shift_options__remove_dates__,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "migration_type is required" if migration_type.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :migration_type => migration_type

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_migrations",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
create_content_migration_users(user_id,migration_type,opts={}) click to toggle source

Create a content migration

# File lib/pandarus/v1_api.rb, line 5977
def create_content_migration_users(user_id,migration_type,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :migration_type,
    :pre_attachment__name__,
    :pre_attachment__x__,
    :settings__file_url__,
    :settings__source_course_id__,
    :settings__folder_id__,
    :settings__overwrite_quizzes__,
    :settings__question_bank_id__,
    :settings__question_bank_name__,
    :date_shift_options__shift_dates__,
    :date_shift_options__old_start_date__,
    :date_shift_options__old_end_date__,
    :date_shift_options__new_start_date__,
    :date_shift_options__new_end_date__,
    :date_shift_options__day_substitutions_____x__,
    :date_shift_options__remove_dates__,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "migration_type is required" if migration_type.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :migration_type => migration_type

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_migrations",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
create_conversation(recipients,body,opts={}) click to toggle source

Create a conversation

# File lib/pandarus/v1_api.rb, line 6346
def create_conversation(recipients,body,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :recipients,
    :subject,
    :body,
    :group_conversation,
    :attachment_ids,
    :media_comment_id,
    :media_comment_type,
    :user_note,
    :mode,
    :scope,
    :filter,
    :filter_mode,
    :context_code,
    

  ]

  # verify existence of params
  raise "recipients is required" if recipients.nil?
  raise "body is required" if body.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :recipients => recipients,
    :body => body

  )

  # resource path
  path = path_replace("/v1/conversations",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_course_section(course_id,opts={}) click to toggle source

Create course section

# File lib/pandarus/v1_api.rb, line 23476
def create_course_section(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :course_section__name__,
    :course_section__sis_section_id__,
    :course_section__start_at__,
    :course_section__end_at__,
    :course_section__restrict_enrollments_to_section_dates__,
    :enable_sis_reactivation,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/sections",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Section.new(response)
  

end
create_custom_gradebook_column(course_id,column__title__,opts={}) click to toggle source

Create a custom gradebook column

# File lib/pandarus/v1_api.rb, line 7864
def create_custom_gradebook_column(course_id,column__title__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :column__title__,
    :column__position__,
    :column__hidden__,
    :column__teacher_notes__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "column__title__ is required" if column__title__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :column__title__ => column__title__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/custom_gradebook_columns",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  CustomColumn.new(response)
  

end
create_enrollment_term(account_id,opts={}) click to toggle source

Create enrollment term

# File lib/pandarus/v1_api.rb, line 9920
def create_enrollment_term(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :enrollment_term__name__,
    :enrollment_term__start_at__,
    :enrollment_term__end_at__,
    :enrollment_term__sis_term_id__,
    :enrollment_term__overrides____enrollment_type____start_at__,
    :enrollment_term__overrides____enrollment_type____end_at__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/terms",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  EnrollmentTerm.new(response)
  

end
create_epub_export(course_id,opts={}) click to toggle source

Create ePub Export

# File lib/pandarus/v1_api.rb, line 26488
def create_epub_export(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/epub_exports",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  EpubExport.new(response)
  

end
create_error_report(error__subject__,opts={}) click to toggle source

Create Error Report

# File lib/pandarus/v1_api.rb, line 10408
def create_error_report(error__subject__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :error__subject__,
    :error__url__,
    :error__email__,
    :error__comments__,
    :error__http_env__,
    

  ]

  # verify existence of params
  raise "error__subject__ is required" if error__subject__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :error__subject__ => error__subject__

  )

  # resource path
  path = path_replace("/v1/error_reports",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_external_feed_courses(course_id,url,opts={}) click to toggle source

Create an external feed

# File lib/pandarus/v1_api.rb, line 1527
def create_external_feed_courses(course_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :url,
    :header_match,
    :verbosity,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_feeds",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ExternalFeed.new(response)
  

end
create_external_feed_groups(group_id,url,opts={}) click to toggle source

Create an external feed

# File lib/pandarus/v1_api.rb, line 1566
def create_external_feed_groups(group_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :url,
    :header_match,
    :verbosity,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/external_feeds",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ExternalFeed.new(response)
  

end
create_external_tool_accounts(account_id,name,privacy_level,consumer_key,shared_secret,opts={}) click to toggle source

Create an external tool

# File lib/pandarus/v1_api.rb, line 10805
def create_external_tool_accounts(account_id,name,privacy_level,consumer_key,shared_secret,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :privacy_level,
    :consumer_key,
    :shared_secret,
    :description,
    :url,
    :domain,
    :icon_url,
    :text,
    :custom_fields__field_name__,
    :account_navigation__url__,
    :account_navigation__enabled__,
    :account_navigation__text__,
    :account_navigation__selection_width__,
    :account_navigation__selection_height__,
    :user_navigation__url__,
    :user_navigation__enabled__,
    :user_navigation__text__,
    :course_home_sub_navigation__url__,
    :course_home_sub_navigation__enabled__,
    :course_home_sub_navigation__text__,
    :course_home_sub_navigation__icon_url__,
    :course_navigation__enabled__,
    :course_navigation__text__,
    :course_navigation__visibility__,
    :course_navigation__window_target__,
    :course_navigation__default__,
    :editor_button__url__,
    :editor_button__enabled__,
    :editor_button__icon_url__,
    :editor_button__selection_width__,
    :editor_button__selection_height__,
    :editor_button__message_type__,
    :homework_submission__url__,
    :homework_submission__enabled__,
    :homework_submission__text__,
    :homework_submission__message_type__,
    :link_selection__url__,
    :link_selection__enabled__,
    :link_selection__text__,
    :link_selection__message_type__,
    :migration_selection__url__,
    :migration_selection__enabled__,
    :migration_selection__message_type__,
    :tool_configuration__url__,
    :tool_configuration__enabled__,
    :tool_configuration__message_type__,
    :tool_configuration__prefer_sis_email__,
    :resource_selection__url__,
    :resource_selection__enabled__,
    :resource_selection__icon_url__,
    :resource_selection__selection_width__,
    :resource_selection__selection_height__,
    :config_type,
    :config_xml,
    :config_url,
    :not_selectable,
    :oauth_compliant,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "name is required" if name.nil?
  raise "privacy_level is required" if privacy_level.nil?
  raise "consumer_key is required" if consumer_key.nil?
  raise "shared_secret is required" if shared_secret.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :name => name,
    :privacy_level => privacy_level,
    :consumer_key => consumer_key,
    :shared_secret => shared_secret

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/external_tools",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_external_tool_courses(course_id,name,privacy_level,consumer_key,shared_secret,opts={}) click to toggle source

Create an external tool

# File lib/pandarus/v1_api.rb, line 10705
def create_external_tool_courses(course_id,name,privacy_level,consumer_key,shared_secret,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :privacy_level,
    :consumer_key,
    :shared_secret,
    :description,
    :url,
    :domain,
    :icon_url,
    :text,
    :custom_fields__field_name__,
    :account_navigation__url__,
    :account_navigation__enabled__,
    :account_navigation__text__,
    :account_navigation__selection_width__,
    :account_navigation__selection_height__,
    :user_navigation__url__,
    :user_navigation__enabled__,
    :user_navigation__text__,
    :course_home_sub_navigation__url__,
    :course_home_sub_navigation__enabled__,
    :course_home_sub_navigation__text__,
    :course_home_sub_navigation__icon_url__,
    :course_navigation__enabled__,
    :course_navigation__text__,
    :course_navigation__visibility__,
    :course_navigation__window_target__,
    :course_navigation__default__,
    :editor_button__url__,
    :editor_button__enabled__,
    :editor_button__icon_url__,
    :editor_button__selection_width__,
    :editor_button__selection_height__,
    :editor_button__message_type__,
    :homework_submission__url__,
    :homework_submission__enabled__,
    :homework_submission__text__,
    :homework_submission__message_type__,
    :link_selection__url__,
    :link_selection__enabled__,
    :link_selection__text__,
    :link_selection__message_type__,
    :migration_selection__url__,
    :migration_selection__enabled__,
    :migration_selection__message_type__,
    :tool_configuration__url__,
    :tool_configuration__enabled__,
    :tool_configuration__message_type__,
    :tool_configuration__prefer_sis_email__,
    :resource_selection__url__,
    :resource_selection__enabled__,
    :resource_selection__icon_url__,
    :resource_selection__selection_width__,
    :resource_selection__selection_height__,
    :config_type,
    :config_xml,
    :config_url,
    :not_selectable,
    :oauth_compliant,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "name is required" if name.nil?
  raise "privacy_level is required" if privacy_level.nil?
  raise "consumer_key is required" if consumer_key.nil?
  raise "shared_secret is required" if shared_secret.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :name => name,
    :privacy_level => privacy_level,
    :consumer_key => consumer_key,
    :shared_secret => shared_secret

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_tools",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_folder_courses(course_id,name,opts={}) click to toggle source

Create folder

# File lib/pandarus/v1_api.rb, line 12880
def create_folder_courses(course_id,name,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :parent_folder_id,
    :parent_folder_path,
    :lock_at,
    :unlock_at,
    :locked,
    :hidden,
    :position,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "name is required" if name.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :name => name

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/folders",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Folder.new(response)
  

end
create_folder_folders(folder_id,name,opts={}) click to toggle source

Create folder

# File lib/pandarus/v1_api.rb, line 13012
def create_folder_folders(folder_id,name,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :parent_folder_id,
    :parent_folder_path,
    :lock_at,
    :unlock_at,
    :locked,
    :hidden,
    :position,
    

  ]

  # verify existence of params
  raise "folder_id is required" if folder_id.nil?
  raise "name is required" if name.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :folder_id => folder_id,
    :name => name

  )

  # resource path
  path = path_replace("/v1/folders/{folder_id}/folders",
    :folder_id => folder_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Folder.new(response)
  

end
create_folder_groups(group_id,name,opts={}) click to toggle source

Create folder

# File lib/pandarus/v1_api.rb, line 12968
def create_folder_groups(group_id,name,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :parent_folder_id,
    :parent_folder_path,
    :lock_at,
    :unlock_at,
    :locked,
    :hidden,
    :position,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "name is required" if name.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :name => name

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/folders",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Folder.new(response)
  

end
create_folder_users(user_id,name,opts={}) click to toggle source

Create folder

# File lib/pandarus/v1_api.rb, line 12924
def create_folder_users(user_id,name,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :parent_folder_id,
    :parent_folder_path,
    :lock_at,
    :unlock_at,
    :locked,
    :hidden,
    :position,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "name is required" if name.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :name => name

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/folders",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Folder.new(response)
  

end
create_global_notification(account_id,account_notification__subject__,account_notification__message__,account_notification__start_at__,account_notification__end_at__,opts={}) click to toggle source

Create a global notification

# File lib/pandarus/v1_api.rb, line 165
def create_global_notification(account_id,account_notification__subject__,account_notification__message__,account_notification__start_at__,account_notification__end_at__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :account_notification__subject__,
    :account_notification__message__,
    :account_notification__start_at__,
    :account_notification__end_at__,
    :account_notification__icon__,
    :account_notification_roles,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "account_notification__subject__ is required" if account_notification__subject__.nil?
  raise "account_notification__message__ is required" if account_notification__message__.nil?
  raise "account_notification__start_at__ is required" if account_notification__start_at__.nil?
  raise "account_notification__end_at__ is required" if account_notification__end_at__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :account_notification__subject__ => account_notification__subject__,
    :account_notification__message__ => account_notification__message__,
    :account_notification__start_at__ => account_notification__start_at__,
    :account_notification__end_at__ => account_notification__end_at__

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/account_notifications",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_group_category_accounts(account_id,name,opts={}) click to toggle source

Create a Group Category

# File lib/pandarus/v1_api.rb, line 14372
def create_group_category_accounts(account_id,name,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :self_signup,
    :auto_leader,
    :group_limit,
    :create_group_count,
    :split_group_count,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "name is required" if name.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :name => name

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/group_categories",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  GroupCategory.new(response)
  

end
create_group_category_courses(course_id,name,opts={}) click to toggle source

Create a Group Category

# File lib/pandarus/v1_api.rb, line 14414
def create_group_category_courses(course_id,name,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :self_signup,
    :auto_leader,
    :group_limit,
    :create_group_count,
    :split_group_count,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "name is required" if name.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :name => name

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/group_categories",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  GroupCategory.new(response)
  

end
create_group_group_categories(group_category_id,opts={}) click to toggle source

Create a group

# File lib/pandarus/v1_api.rb, line 14805
def create_group_group_categories(group_category_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :description,
    :is_public,
    :join_level,
    :storage_quota_mb,
    

  ]

  # verify existence of params
  raise "group_category_id is required" if group_category_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_category_id => group_category_id

  )

  # resource path
  path = path_replace("/v1/group_categories/{group_category_id}/groups",
    :group_category_id => group_category_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Group.new(response)
  

end
create_group_groups(opts={}) click to toggle source

Create a group

# File lib/pandarus/v1_api.rb, line 14767
def create_group_groups(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :description,
    :is_public,
    :join_level,
    :storage_quota_mb,
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/groups",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Group.new(response)
  

end
create_jwt(opts={}) click to toggle source

Create JWT

# File lib/pandarus/v1_api.rb, line 15421
def create_jwt(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/jwts",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  JWT.new(response)
  

end
create_late_policy(id,opts={}) click to toggle source

Create a late policy

# File lib/pandarus/v1_api.rb, line 15523
def create_late_policy(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :late_policy__missing_submission_deduction_enabled__,
    :late_policy__missing_submission_deduction__,
    :late_policy__late_submission_deduction_enabled__,
    :late_policy__late_submission_deduction__,
    :late_policy__late_submission_interval__,
    :late_policy__late_submission_minimum_percent_enabled__,
    :late_policy__late_submission_minimum_percent__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{id}/late_policy",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_live_assessment_results(course_id,assessment_id,opts={}) click to toggle source

Create live assessment results

# File lib/pandarus/v1_api.rb, line 15605
def create_live_assessment_results(course_id,assessment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assessment_id is required" if assessment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assessment_id => assessment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/live_assessments/{assessment_id}/results",
    :course_id => course_id,
    :assessment_id => assessment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_membership(group_id,opts={}) click to toggle source

Create a membership

# File lib/pandarus/v1_api.rb, line 15234
def create_membership(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user_id,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/memberships",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  GroupMembership.new(response)
  

end
create_module(course_id,module__name__,opts={}) click to toggle source

Create a module

# File lib/pandarus/v1_api.rb, line 16237
def create_module(course_id,module__name__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :module__name__,
    :module__unlock_at__,
    :module__position__,
    :module__require_sequential_progress__,
    :module__prerequisite_module_ids__,
    :module__publish_final_grade__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module__name__ is required" if module__name__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module__name__ => module__name__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Module.new(response)
  

end
create_module_item(course_id,module_id,module_item__type__,module_item__content_id__,opts={}) click to toggle source

Create a module item

# File lib/pandarus/v1_api.rb, line 16476
def create_module_item(course_id,module_id,module_item__type__,module_item__content_id__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :module_item__title__,
    :module_item__type__,
    :module_item__content_id__,
    :module_item__position__,
    :module_item__indent__,
    :module_item__page_url__,
    :module_item__external_url__,
    :module_item__new_tab__,
    :module_item__completion_requirement____type__,
    :module_item__completion_requirement____min_score__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module_id is required" if module_id.nil?
  raise "module_item__type__ is required" if module_item__type__.nil?
  raise "module_item__content_id__ is required" if module_item__content_id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module_id => module_id,
    :module_item__type__ => module_item__type__,
    :module_item__content_id__ => module_item__content_id__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{module_id}/items",
    :course_id => course_id,
    :module_id => module_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ModuleItem.new(response)
  

end
create_new_course(account_id,opts={}) click to toggle source

Create a new course

# File lib/pandarus/v1_api.rb, line 6943
def create_new_course(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :course__name__,
    :course__course_code__,
    :course__start_at__,
    :course__end_at__,
    :course__license__,
    :course__is_public__,
    :course__is_public_to_auth_users__,
    :course__public_syllabus__,
    :course__public_syllabus_to_auth__,
    :course__public_description__,
    :course__allow_student_wiki_edits__,
    :course__allow_wiki_comments__,
    :course__allow_student_forum_attachments__,
    :course__open_enrollment__,
    :course__self_enrollment__,
    :course__restrict_enrollments_to_course_dates__,
    :course__term_id__,
    :course__sis_course_id__,
    :course__integration_id__,
    :course__hide_final_grades__,
    :course__apply_assignment_group_weights__,
    :course__time_zone__,
    :offer,
    :enroll_me,
    :course__syllabus_body__,
    :course__grading_standard_id__,
    :course__course_format__,
    :enable_sis_reactivation,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/courses",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Course.new(response)
  

end
create_new_discussion_topic_courses(course_id,opts={}) click to toggle source

Create a new discussion topic

# File lib/pandarus/v1_api.rb, line 8170
def create_new_discussion_topic_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :message,
    :discussion_type,
    :published,
    :delayed_post_at,
    :allow_rating,
    :lock_at,
    :podcast_enabled,
    :podcast_has_student_posts,
    :require_initial_post,
    :assignment,
    :is_announcement,
    :pinned,
    :position_after,
    :group_category_id,
    :only_graders_can_rate,
    :sort_by_rating,
    :attachment,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_new_discussion_topic_groups(group_id,opts={}) click to toggle source

Create a new discussion topic

# File lib/pandarus/v1_api.rb, line 8222
def create_new_discussion_topic_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :message,
    :discussion_type,
    :published,
    :delayed_post_at,
    :allow_rating,
    :lock_at,
    :podcast_enabled,
    :podcast_has_student_posts,
    :require_initial_post,
    :assignment,
    :is_announcement,
    :pinned,
    :position_after,
    :group_category_id,
    :only_graders_can_rate,
    :sort_by_rating,
    :attachment,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_new_grading_standard_accounts(account_id,title,grading_scheme_entry__name__,grading_scheme_entry__value__,opts={}) click to toggle source

Create a new grading standard

# File lib/pandarus/v1_api.rb, line 14046
def create_new_grading_standard_accounts(account_id,title,grading_scheme_entry__name__,grading_scheme_entry__value__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :grading_scheme_entry__name__,
    :grading_scheme_entry__value__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "title is required" if title.nil?
  raise "grading_scheme_entry__name__ is required" if grading_scheme_entry__name__.nil?
  raise "grading_scheme_entry__value__ is required" if grading_scheme_entry__value__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :title => title,
    :grading_scheme_entry__name__ => grading_scheme_entry__name__,
    :grading_scheme_entry__value__ => grading_scheme_entry__value__

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/grading_standards",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  GradingStandard.new(response)
  

end
create_new_grading_standard_courses(course_id,title,grading_scheme_entry__name__,grading_scheme_entry__value__,opts={}) click to toggle source

Create a new grading standard

# File lib/pandarus/v1_api.rb, line 14089
def create_new_grading_standard_courses(course_id,title,grading_scheme_entry__name__,grading_scheme_entry__value__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :grading_scheme_entry__name__,
    :grading_scheme_entry__value__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "title is required" if title.nil?
  raise "grading_scheme_entry__name__ is required" if grading_scheme_entry__name__.nil?
  raise "grading_scheme_entry__value__ is required" if grading_scheme_entry__value__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :title => title,
    :grading_scheme_entry__name__ => grading_scheme_entry__name__,
    :grading_scheme_entry__value__ => grading_scheme_entry__value__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/grading_standards",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  GradingStandard.new(response)
  

end
create_new_role(account_id,label,opts={}) click to toggle source

Create a new role

# File lib/pandarus/v1_api.rb, line 22831
def create_new_role(account_id,label,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :label,
    :role,
    :base_role_type,
    :permissions____x_____explicit__,
    :permissions____x_____enabled__,
    :permissions____x_____locked__,
    :permissions____x_____applies_to_self__,
    :permissions____x_____applies_to_descendants__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "label is required" if label.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :label => label

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/roles",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Role.new(response)
  

end
create_new_sub_account(account_id,account__name__,opts={}) click to toggle source

Create a new sub-account

# File lib/pandarus/v1_api.rb, line 743
def create_new_sub_account(account_id,account__name__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :account__name__,
    :account__sis_account_id__,
    :account__default_storage_quota_mb__,
    :account__default_user_storage_quota_mb__,
    :account__default_group_storage_quota_mb__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "account__name__ is required" if account__name__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :account__name__ => account__name__

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sub_accounts",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Account.new(response)
  

end
create_or_find_live_assessment(course_id,opts={}) click to toggle source

Create or find a live assessment

# File lib/pandarus/v1_api.rb, line 15679
def create_or_find_live_assessment(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/live_assessments",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_or_update_events_directly_for_course_timetable(course_id,opts={}) click to toggle source

Create or update events directly for a course timetable

# File lib/pandarus/v1_api.rb, line 4283
def create_or_update_events_directly_for_course_timetable(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :course_section_id,
    :events,
    :events__start_at__,
    :events__end_at__,
    :events__location_name__,
    :events__code__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/calendar_events/timetable_events",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_page_courses(course_id,wiki_page__title__,opts={}) click to toggle source

Create page

# File lib/pandarus/v1_api.rb, line 18993
def create_page_courses(course_id,wiki_page__title__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :wiki_page__title__,
    :wiki_page__body__,
    :wiki_page__editing_roles__,
    :wiki_page__notify_of_update__,
    :wiki_page__published__,
    :wiki_page__front_page__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "wiki_page__title__ is required" if wiki_page__title__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :wiki_page__title__ => wiki_page__title__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Page.new(response)
  

end
create_page_groups(group_id,wiki_page__title__,opts={}) click to toggle source

Create page

# File lib/pandarus/v1_api.rb, line 19035
def create_page_groups(group_id,wiki_page__title__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :wiki_page__title__,
    :wiki_page__body__,
    :wiki_page__editing_roles__,
    :wiki_page__notify_of_update__,
    :wiki_page__published__,
    :wiki_page__front_page__,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "wiki_page__title__ is required" if wiki_page__title__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :wiki_page__title__ => wiki_page__title__

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Page.new(response)
  

end
create_peer_review_courses(course_id,assignment_id,submission_id,user_id,opts={}) click to toggle source

Create Peer Review

# File lib/pandarus/v1_api.rb, line 19767
def create_peer_review_courses(course_id,assignment_id,submission_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user_id,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "submission_id is required" if submission_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{submission_id}/peer_reviews",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  PeerReview.new(response)
  

end
create_peer_review_sections(section_id,assignment_id,submission_id,user_id,opts={}) click to toggle source

Create Peer Review

# File lib/pandarus/v1_api.rb, line 19810
def create_peer_review_sections(section_id,assignment_id,submission_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user_id,
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "submission_id is required" if submission_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/{submission_id}/peer_reviews",
    :section_id => section_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  PeerReview.new(response)
  

end
create_planner_note(opts={}) click to toggle source

Create a planner note

# File lib/pandarus/v1_api.rb, line 20043
def create_planner_note(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :details,
    :todo_date,
    :course_id,
    :linked_object_type,
    :linked_object_id,
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/planner_notes",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  PlannerNote.new(response)
  

end
create_planner_override(opts={}) click to toggle source

Create a planner override

# File lib/pandarus/v1_api.rb, line 20253
def create_planner_override(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :plannable_type,
    :plannable_id,
    :marked_complete,
    :dismissed,
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/planner/overrides",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  PlannerOverride.new(response)
  

end
create_question_group(course_id,quiz_id,opts={}) click to toggle source

Create a question group

# File lib/pandarus/v1_api.rb, line 21285
def create_question_group(course_id,quiz_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :quiz_groups__name__,
    :quiz_groups__pick_count__,
    :quiz_groups__question_points__,
    :quiz_groups__assessment_question_bank_id__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/groups",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_quiz(course_id,quiz__title__,opts={}) click to toggle source

Create a quiz

# File lib/pandarus/v1_api.rb, line 22542
def create_quiz(course_id,quiz__title__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :quiz__title__,
    :quiz__description__,
    :quiz__quiz_type__,
    :quiz__assignment_group_id__,
    :quiz__time_limit__,
    :quiz__shuffle_answers__,
    :quiz__hide_results__,
    :quiz__show_correct_answers__,
    :quiz__show_correct_answers_last_attempt__,
    :quiz__show_correct_answers_at__,
    :quiz__hide_correct_answers_at__,
    :quiz__allowed_attempts__,
    :quiz__scoring_policy__,
    :quiz__one_question_at_a_time__,
    :quiz__cant_go_back__,
    :quiz__access_code__,
    :quiz__ip_filter__,
    :quiz__due_at__,
    :quiz__lock_at__,
    :quiz__unlock_at__,
    :quiz__published__,
    :quiz__one_time_results__,
    :quiz__only_visible_to_overrides__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz__title__ is required" if quiz__title__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz__title__ => quiz__title__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Quiz.new(response)
  

end
create_quiz_report(course_id,quiz_id,quiz_report__report_type__,opts={}) click to toggle source

Create a quiz report

# File lib/pandarus/v1_api.rb, line 21705
def create_quiz_report(course_id,quiz_id,quiz_report__report_type__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :quiz_report__report_type__,
    :quiz_report__includes_all_versions__,
    :include,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "quiz_report__report_type__ is required" if quiz_report__report_type__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :quiz_report__report_type__ => quiz_report__report_type__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/reports",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  QuizReport.new(response)
  

end
create_quiz_submission_start_quiz_taking_session(course_id,quiz_id,opts={}) click to toggle source

Create the quiz submission (start a quiz-taking session)

# File lib/pandarus/v1_api.rb, line 22301
def create_quiz_submission_start_quiz_taking_session(course_id,quiz_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :access_code,
    :preview,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_single_poll(polls__question__,opts={}) click to toggle source

Create a single poll

# File lib/pandarus/v1_api.rb, line 20987
def create_single_poll(polls__question__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :polls__question__,
    :polls__description__,
    

  ]

  # verify existence of params
  raise "polls__question__ is required" if polls__question__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :polls__question__ => polls__question__

  )

  # resource path
  path = path_replace("/v1/polls",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_single_poll_choice(poll_id,poll_choices__text__,opts={}) click to toggle source

Create a single poll choice

# File lib/pandarus/v1_api.rb, line 20722
def create_single_poll_choice(poll_id,poll_choices__text__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :poll_choices__text__,
    :poll_choices__is_correct__,
    :poll_choices__position__,
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "poll_choices__text__ is required" if poll_choices__text__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :poll_choices__text__ => poll_choices__text__

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_choices",
    :poll_id => poll_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_single_poll_session(poll_id,poll_sessions__course_id__,opts={}) click to toggle source

Create a single poll session

# File lib/pandarus/v1_api.rb, line 20395
def create_single_poll_session(poll_id,poll_sessions__course_id__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :poll_sessions__course_id__,
    :poll_sessions__course_section_id__,
    :poll_sessions__has_public_results__,
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "poll_sessions__course_id__ is required" if poll_sessions__course_id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :poll_sessions__course_id__ => poll_sessions__course_id__

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions",
    :poll_id => poll_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_single_poll_submission(poll_id,poll_session_id,poll_submissions__poll_choice_id__,opts={}) click to toggle source

Create a single poll submission

# File lib/pandarus/v1_api.rb, line 20880
def create_single_poll_submission(poll_id,poll_session_id,poll_submissions__poll_choice_id__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :poll_submissions__poll_choice_id__,
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "poll_session_id is required" if poll_session_id.nil?
  raise "poll_submissions__poll_choice_id__ is required" if poll_submissions__poll_choice_id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :poll_session_id => poll_session_id,
    :poll_submissions__poll_choice_id__ => poll_submissions__poll_choice_id__

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions/{poll_session_id}/poll_submissions",
    :poll_id => poll_id,
    :poll_session_id => poll_session_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
create_single_quiz_question(course_id,quiz_id,opts={}) click to toggle source

Create a single quiz question

# File lib/pandarus/v1_api.rb, line 21530
def create_single_quiz_question(course_id,quiz_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :question__question_name__,
    :question__question_text__,
    :question__quiz_group_id__,
    :question__question_type__,
    :question__position__,
    :question__points_possible__,
    :question__correct_comments__,
    :question__incorrect_comments__,
    :question__neutral_comments__,
    :question__text_after_answers__,
    :question__answers__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/questions",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  QuizQuestion.new(response)
  

end
create_subgroup_accounts(account_id,id,title,opts={}) click to toggle source

Create a subgroup

# File lib/pandarus/v1_api.rb, line 18387
def create_subgroup_accounts(account_id,id,title,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :description,
    :vendor_guid,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  raise "title is required" if title.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id,
    :title => title

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/outcome_groups/{id}/subgroups",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
create_subgroup_courses(course_id,id,title,opts={}) click to toggle source

Create a subgroup

# File lib/pandarus/v1_api.rb, line 18429
def create_subgroup_courses(course_id,id,title,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :description,
    :vendor_guid,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  raise "title is required" if title.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id,
    :title => title

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_groups/{id}/subgroups",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
create_subgroup_global(id,title,opts={}) click to toggle source

Create a subgroup

# File lib/pandarus/v1_api.rb, line 18348
def create_subgroup_global(id,title,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :description,
    :vendor_guid,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "title is required" if title.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :title => title

  )

  # resource path
  path = path_replace("/v1/global/outcome_groups/{id}/subgroups",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
create_user(account_id,pseudonym__unique_id__,opts={}) click to toggle source

Create a user

# File lib/pandarus/v1_api.rb, line 25602
def create_user(account_id,pseudonym__unique_id__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user__name__,
    :user__short_name__,
    :user__sortable_name__,
    :user__time_zone__,
    :user__locale__,
    :user__birthdate__,
    :user__terms_of_use__,
    :user__skip_registration__,
    :pseudonym__unique_id__,
    :pseudonym__password__,
    :pseudonym__sis_user_id__,
    :pseudonym__integration_id__,
    :pseudonym__send_confirmation__,
    :pseudonym__force_self_registration__,
    :pseudonym__authentication_provider_id__,
    :communication_channel__type__,
    :communication_channel__address__,
    :communication_channel__confirmation_url__,
    :communication_channel__skip_confirmation__,
    :force_validations,
    :enable_sis_reactivation,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "pseudonym__unique_id__ is required" if pseudonym__unique_id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :pseudonym__unique_id__ => pseudonym__unique_id__

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/users",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  User.new(response)
  

end
create_user_login(account_id,user__id__,login__unique_id__,opts={}) click to toggle source

Create a user login

# File lib/pandarus/v1_api.rb, line 15815
def create_user_login(account_id,user__id__,login__unique_id__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user__id__,
    :login__unique_id__,
    :login__password__,
    :login__sis_user_id__,
    :login__integration_id__,
    :login__authentication_provider_id__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "user__id__ is required" if user__id__.nil?
  raise "login__unique_id__ is required" if login__unique_id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :user__id__ => user__id__,
    :login__unique_id__ => login__unique_id__

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/logins",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
cross_list_section(id,new_course_id,opts={}) click to toggle source

Cross-list a Section

# File lib/pandarus/v1_api.rb, line 23516
def cross_list_section(id,new_course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "new_course_id is required" if new_course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :new_course_id => new_course_id

  )

  # resource path
  path = path_replace("/v1/sections/{id}/crosslist/{new_course_id}",
    :id => id,
    :new_course_id => new_course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Section.new(response)
  

end
days_in_gradebook_history_for_this_course(course_id,opts={}) click to toggle source

Days in gradebook history for this course

# File lib/pandarus/v1_api.rb, line 13677
def days_in_gradebook_history_for_this_course(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/gradebook_history/days",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Day, path, query_params)
  

end
de_cross_list_section(id,opts={}) click to toggle source

De-cross-list a Section

# File lib/pandarus/v1_api.rb, line 23553
def de_cross_list_section(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/sections/{id}/crosslist",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Section.new(response)
  

end
deactivate_role(account_id,id,role_id,opts={}) click to toggle source

Deactivate a role

# File lib/pandarus/v1_api.rb, line 22875
def deactivate_role(account_id,id,role_id,opts={})
  query_param_keys = [
    :role_id,
    :role

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  raise "role_id is required" if role_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id,
    :role_id => role_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/roles/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Role.new(response)
  

end
delete_appointment_group(id,opts={}) click to toggle source

Delete an appointment group

# File lib/pandarus/v1_api.rb, line 1881
def delete_appointment_group(id,opts={})
  query_param_keys = [
    :cancel_reason

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/appointment_groups/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_assignment(course_id,id,opts={}) click to toggle source

Delete an assignment

# File lib/pandarus/v1_api.rb, line 2205
def delete_assignment(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Assignment.new(response)
  

end
delete_assignment_override(course_id,assignment_id,id,opts={}) click to toggle source

Delete an assignment override

# File lib/pandarus/v1_api.rb, line 2727
def delete_assignment_override(course_id,assignment_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/overrides/{id}",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  AssignmentOverride.new(response)
  

end
delete_authentication_provider(account_id,id,opts={}) click to toggle source

Delete authentication provider

# File lib/pandarus/v1_api.rb, line 3018
def delete_authentication_provider(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/authentication_providers/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_bookmark(id,opts={}) click to toggle source

Delete bookmark

# File lib/pandarus/v1_api.rb, line 3828
def delete_bookmark(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/self/bookmarks/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_calendar_event(id,opts={}) click to toggle source

Delete a calendar event

# File lib/pandarus/v1_api.rb, line 4176
def delete_calendar_event(id,opts={})
  query_param_keys = [
    :cancel_reason

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/calendar_events/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_communication_channel_id(user_id,id,opts={}) click to toggle source

Delete a communication channel

# File lib/pandarus/v1_api.rb, line 4598
def delete_communication_channel_id(user_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels/{id}",
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  CommunicationChannel.new(response)
  

end
delete_communication_channel_type(user_id,type,address,opts={}) click to toggle source

Delete a communication channel

# File lib/pandarus/v1_api.rb, line 4635
def delete_communication_channel_type(user_id,type,address,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "type is required" if type.nil?
  raise "address is required" if address.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :type => type,
    :address => address

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels/{type}/{address}",
    :user_id => user_id,
    :type => type,
    :address => address)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  CommunicationChannel.new(response)
  

end
delete_conclude_course(id,event,opts={}) click to toggle source

Delete/Conclude a course

# File lib/pandarus/v1_api.rb, line 7359
def delete_conclude_course(id,event,opts={})
  query_param_keys = [
    :event

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "event is required" if event.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :event => event

  )

  # resource path
  path = path_replace("/v1/courses/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_conversation(id,opts={}) click to toggle source

Delete a conversation

# File lib/pandarus/v1_api.rb, line 6539
def delete_conversation(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/conversations/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_custom_data(user_id,ns,opts={}) click to toggle source

Delete custom data

# File lib/pandarus/v1_api.rb, line 26250
def delete_custom_data(user_id,ns,opts={})
  query_param_keys = [
    :ns

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "ns is required" if ns.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :ns => ns

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/custom_data",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_custom_gradebook_column(course_id,id,opts={}) click to toggle source

Delete a custom gradebook column

# File lib/pandarus/v1_api.rb, line 7941
def delete_custom_gradebook_column(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/custom_gradebook_columns/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  CustomColumn.new(response)
  

end
delete_enrollment_term(account_id,id,opts={}) click to toggle source

Delete enrollment term

# File lib/pandarus/v1_api.rb, line 10003
def delete_enrollment_term(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/terms/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  EnrollmentTerm.new(response)
  

end
delete_entry_courses(course_id,topic_id,id,opts={}) click to toggle source

Delete an entry

# File lib/pandarus/v1_api.rb, line 8612
def delete_entry_courses(course_id,topic_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries/{id}",
    :course_id => course_id,
    :topic_id => topic_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_entry_groups(group_id,topic_id,id,opts={}) click to toggle source

Delete an entry

# File lib/pandarus/v1_api.rb, line 8652
def delete_entry_groups(group_id,topic_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries/{id}",
    :group_id => group_id,
    :topic_id => topic_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_external_feed_courses(course_id,external_feed_id,opts={}) click to toggle source

Delete an external feed

# File lib/pandarus/v1_api.rb, line 1605
def delete_external_feed_courses(course_id,external_feed_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "external_feed_id is required" if external_feed_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :external_feed_id => external_feed_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_feeds/{external_feed_id}",
    :course_id => course_id,
    :external_feed_id => external_feed_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  ExternalFeed.new(response)
  

end
delete_external_feed_groups(group_id,external_feed_id,opts={}) click to toggle source

Delete an external feed

# File lib/pandarus/v1_api.rb, line 1642
def delete_external_feed_groups(group_id,external_feed_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "external_feed_id is required" if external_feed_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :external_feed_id => external_feed_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/external_feeds/{external_feed_id}",
    :group_id => group_id,
    :external_feed_id => external_feed_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  ExternalFeed.new(response)
  

end
delete_external_tool_accounts(account_id,external_tool_id,opts={}) click to toggle source

Delete an external tool

# File lib/pandarus/v1_api.rb, line 11016
def delete_external_tool_accounts(account_id,external_tool_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "external_tool_id is required" if external_tool_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :external_tool_id => external_tool_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/external_tools/{external_tool_id}",
    :account_id => account_id,
    :external_tool_id => external_tool_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_external_tool_courses(course_id,external_tool_id,opts={}) click to toggle source

Delete an external tool

# File lib/pandarus/v1_api.rb, line 10979
def delete_external_tool_courses(course_id,external_tool_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "external_tool_id is required" if external_tool_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :external_tool_id => external_tool_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_tools/{external_tool_id}",
    :course_id => course_id,
    :external_tool_id => external_tool_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_file(id,opts={}) click to toggle source

Delete file

# File lib/pandarus/v1_api.rb, line 12330
def delete_file(id,opts={})
  query_param_keys = [
    :replace

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/files/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  File.new(response)
  

end
delete_folder(id,opts={}) click to toggle source

Delete folder

# File lib/pandarus/v1_api.rb, line 13056
def delete_folder(id,opts={})
  query_param_keys = [
    :force

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/folders/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_grading_period_accounts(account_id,id,opts={}) click to toggle source

Delete a grading period

# File lib/pandarus/v1_api.rb, line 14009
def delete_grading_period_accounts(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/grading_periods/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_grading_period_courses(course_id,id,opts={}) click to toggle source

Delete a grading period

# File lib/pandarus/v1_api.rb, line 13972
def delete_grading_period_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/grading_periods/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_group(group_id,opts={}) click to toggle source

Delete a group

# File lib/pandarus/v1_api.rb, line 14885
def delete_group(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Group.new(response)
  

end
delete_group_category(group_category_id,opts={}) click to toggle source

Delete a Group Category

# File lib/pandarus/v1_api.rb, line 14496
def delete_group_category(group_category_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_category_id is required" if group_category_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_category_id => group_category_id

  )

  # resource path
  path = path_replace("/v1/group_categories/{group_category_id}",
    :group_category_id => group_category_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_message(id,remove,opts={}) click to toggle source

Delete a message

# File lib/pandarus/v1_api.rb, line 6653
def delete_message(id,remove,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :remove,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "remove is required" if remove.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :remove => remove

  )

  # resource path
  path = path_replace("/v1/conversations/{id}/remove_messages",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
delete_module(course_id,id,opts={}) click to toggle source

Delete module

# File lib/pandarus/v1_api.rb, line 16323
def delete_module(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Module.new(response)
  

end
delete_module_item(course_id,module_id,id,opts={}) click to toggle source

Delete module item

# File lib/pandarus/v1_api.rb, line 16618
def delete_module_item(course_id,module_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module_id is required" if module_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module_id => module_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{module_id}/items/{id}",
    :course_id => course_id,
    :module_id => module_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  ModuleItem.new(response)
  

end
delete_outcome_group_accounts(account_id,id,opts={}) click to toggle source

Delete an outcome group

# File lib/pandarus/v1_api.rb, line 17665
def delete_outcome_group_accounts(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/outcome_groups/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
delete_outcome_group_courses(course_id,id,opts={}) click to toggle source

Delete an outcome group

# File lib/pandarus/v1_api.rb, line 17702
def delete_outcome_group_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_groups/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
delete_outcome_group_global(id,opts={}) click to toggle source

Delete an outcome group

# File lib/pandarus/v1_api.rb, line 17631
def delete_outcome_group_global(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/global/outcome_groups/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
delete_page_courses(course_id,url,opts={}) click to toggle source

Delete page

# File lib/pandarus/v1_api.rb, line 19237
def delete_page_courses(course_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages/{url}",
    :course_id => course_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Page.new(response)
  

end
delete_page_groups(group_id,url,opts={}) click to toggle source

Delete page

# File lib/pandarus/v1_api.rb, line 19274
def delete_page_groups(group_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages/{url}",
    :group_id => group_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Page.new(response)
  

end
delete_peer_review_courses(course_id,assignment_id,submission_id,user_id,opts={}) click to toggle source

Delete Peer Review

# File lib/pandarus/v1_api.rb, line 19853
def delete_peer_review_courses(course_id,assignment_id,submission_id,user_id,opts={})
  query_param_keys = [
    :user_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "submission_id is required" if submission_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{submission_id}/peer_reviews",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  PeerReview.new(response)
  

end
delete_peer_review_sections(section_id,assignment_id,submission_id,user_id,opts={}) click to toggle source

Delete Peer Review

# File lib/pandarus/v1_api.rb, line 19895
def delete_peer_review_sections(section_id,assignment_id,submission_id,user_id,opts={})
  query_param_keys = [
    :user_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "submission_id is required" if submission_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/{submission_id}/peer_reviews",
    :section_id => section_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  PeerReview.new(response)
  

end
delete_planner_note(id,opts={}) click to toggle source

Delete a planner note

# File lib/pandarus/v1_api.rb, line 20082
def delete_planner_note(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/planner_notes/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  PlannerNote.new(response)
  

end
delete_planner_override(id,opts={}) click to toggle source

Delete a planner override

# File lib/pandarus/v1_api.rb, line 20290
def delete_planner_override(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/planner/overrides/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  PlannerOverride.new(response)
  

end
delete_poll(id,opts={}) click to toggle source

Delete a poll

# File lib/pandarus/v1_api.rb, line 21061
def delete_poll(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_poll_choice(poll_id,id,opts={}) click to toggle source

Delete a poll choice

# File lib/pandarus/v1_api.rb, line 20803
def delete_poll_choice(poll_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_choices/{id}",
    :poll_id => poll_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_poll_session(poll_id,id,opts={}) click to toggle source

Delete a poll session

# File lib/pandarus/v1_api.rb, line 20474
def delete_poll_session(poll_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions/{id}",
    :poll_id => poll_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_question_group(course_id,quiz_id,id,opts={}) click to toggle source

Delete a question group

# File lib/pandarus/v1_api.rb, line 21369
def delete_question_group(course_id,quiz_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/groups/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_quiz(course_id,id,opts={}) click to toggle source

Delete a quiz

# File lib/pandarus/v1_api.rb, line 22639
def delete_quiz(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Quiz.new(response)
  

end
delete_quiz_question(course_id,quiz_id,id,opts={}) click to toggle source

Delete a quiz question

# File lib/pandarus/v1_api.rb, line 21629
def delete_quiz_question(course_id,quiz_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/questions/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_report(account_id,report,id,opts={}) click to toggle source

Delete a Report

# File lib/pandarus/v1_api.rb, line 404
def delete_report(account_id,report,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "report is required" if report.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :report => report,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/reports/{report}/{id}",
    :account_id => account_id,
    :report => report,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Report.new(response)
  

end
delete_section(id,opts={}) click to toggle source

Delete a section

# File lib/pandarus/v1_api.rb, line 23698
def delete_section(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/sections/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Section.new(response)
  

end
delete_sub_account(account_id,id,opts={}) click to toggle source

Delete a sub-account

# File lib/pandarus/v1_api.rb, line 784
def delete_sub_account(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sub_accounts/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Account.new(response)
  

end
delete_topic_courses(course_id,topic_id,opts={}) click to toggle source

Delete a topic

# File lib/pandarus/v1_api.rb, line 8382
def delete_topic_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_topic_groups(group_id,topic_id,opts={}) click to toggle source

Delete a topic

# File lib/pandarus/v1_api.rb, line 8419
def delete_topic_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
delete_user_from_root_account(account_id,user_id,opts={}) click to toggle source

Delete a user from the root account

# File lib/pandarus/v1_api.rb, line 706
def delete_user_from_root_account(account_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/users/{user_id}",
    :account_id => account_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  User.new(response)
  

end
delete_user_login(user_id,id,opts={}) click to toggle source

Delete a user login

# File lib/pandarus/v1_api.rb, line 15900
def delete_user_login(user_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/logins/{id}",
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
destroy_assignment_group(course_id,assignment_group_id,opts={}) click to toggle source

Destroy an Assignment Group

# File lib/pandarus/v1_api.rb, line 2168
def destroy_assignment_group(course_id,assignment_group_id,opts={})
  query_param_keys = [
    :move_assignments_to

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_group_id is required" if assignment_group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_group_id => assignment_group_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignment_groups/{assignment_group_id}",
    :course_id => course_id,
    :assignment_group_id => assignment_group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  AssignmentGroup.new(response)
  

end
details_for_given_date_in_gradebook_history_for_this_course(course_id,date,opts={}) click to toggle source

Details for a given date in gradebook history for this course

# File lib/pandarus/v1_api.rb, line 13710
def details_for_given_date_in_gradebook_history_for_this_course(course_id,date,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "date is required" if date.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :date => date

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/gradebook_history/{date}",
    :course_id => course_id,
    :date => date)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Grader, path, query_params)
  

end
duplicate_page(course_id,url,opts={}) click to toggle source

Duplicate page

# File lib/pandarus/v1_api.rb, line 18806
def duplicate_page(course_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages/{url}/duplicate",
    :course_id => course_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Page.new(response)
  

end
edit_assignment(course_id,id,opts={}) click to toggle source

Edit an assignment

# File lib/pandarus/v1_api.rb, line 2423
def edit_assignment(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :assignment__name__,
    :assignment__position__,
    :assignment__submission_types__,
    :assignment__allowed_extensions__,
    :assignment__turnitin_enabled__,
    :assignment__vericite_enabled__,
    :assignment__turnitin_settings__,
    :assignment__integration_data__,
    :assignment__integration_id__,
    :assignment__peer_reviews__,
    :assignment__automatic_peer_reviews__,
    :assignment__notify_of_update__,
    :assignment__group_category_id__,
    :assignment__grade_group_students_individually__,
    :assignment__external_tool_tag_attributes__,
    :assignment__points_possible__,
    :assignment__grading_type__,
    :assignment__due_at__,
    :assignment__lock_at__,
    :assignment__unlock_at__,
    :assignment__description__,
    :assignment__assignment_group_id__,
    :assignment__muted__,
    :assignment__assignment_overrides__,
    :assignment__only_visible_to_overrides__,
    :assignment__published__,
    :assignment__grading_standard_id__,
    :assignment__omit_from_final_grade__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Assignment.new(response)
  

end
edit_assignment_group(course_id,assignment_group_id,opts={}) click to toggle source

Edit an Assignment Group

# File lib/pandarus/v1_api.rb, line 2131
def edit_assignment_group(course_id,assignment_group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_group_id is required" if assignment_group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_group_id => assignment_group_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignment_groups/{assignment_group_id}",
    :course_id => course_id,
    :assignment_group_id => assignment_group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  AssignmentGroup.new(response)
  

end
edit_conversation(id,opts={}) click to toggle source

Edit a conversation

# File lib/pandarus/v1_api.rb, line 6466
def edit_conversation(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :conversation__workflow_state__,
    :conversation__subscribed__,
    :conversation__starred__,
    :scope,
    :filter,
    :filter_mode,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/conversations/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
edit_external_tool_accounts(account_id,external_tool_id,opts={}) click to toggle source

Edit an external tool

# File lib/pandarus/v1_api.rb, line 10942
def edit_external_tool_accounts(account_id,external_tool_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "external_tool_id is required" if external_tool_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :external_tool_id => external_tool_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/external_tools/{external_tool_id}",
    :account_id => account_id,
    :external_tool_id => external_tool_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
edit_external_tool_courses(course_id,external_tool_id,opts={}) click to toggle source

Edit an external tool

# File lib/pandarus/v1_api.rb, line 10905
def edit_external_tool_courses(course_id,external_tool_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "external_tool_id is required" if external_tool_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :external_tool_id => external_tool_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_tools/{external_tool_id}",
    :course_id => course_id,
    :external_tool_id => external_tool_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
edit_group(group_id,opts={}) click to toggle source

Edit a group

# File lib/pandarus/v1_api.rb, line 14844
def edit_group(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :description,
    :is_public,
    :join_level,
    :avatar_id,
    :storage_quota_mb,
    :members,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Group.new(response)
  

end
edit_quiz(course_id,id,opts={}) click to toggle source

Edit a quiz

# File lib/pandarus/v1_api.rb, line 22601
def edit_quiz(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :quiz__notify_of_update__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Quiz.new(response)
  

end
edit_section(id,opts={}) click to toggle source

Edit a section

# File lib/pandarus/v1_api.rb, line 23587
def edit_section(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :course_section__name__,
    :course_section__sis_section_id__,
    :course_section__integration_id__,
    :course_section__start_at__,
    :course_section__end_at__,
    :course_section__restrict_enrollments_to_section_dates__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/sections/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Section.new(response)
  

end
edit_user(id,opts={}) click to toggle source

Edit a user

# File lib/pandarus/v1_api.rb, line 25921
def edit_user(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user__name__,
    :user__short_name__,
    :user__sortable_name__,
    :user__time_zone__,
    :user__email__,
    :user__locale__,
    :user__avatar____token__,
    :user__avatar____url__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  User.new(response)
  

end
edit_user_login(account_id,id,opts={}) click to toggle source

Edit a user login

# File lib/pandarus/v1_api.rb, line 15859
def edit_user_login(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :login__unique_id__,
    :login__password__,
    :login__sis_user_id__,
    :login__integration_id__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/logins/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
enroll_user_courses(course_id,enrollment__user_id__,enrollment__type__,opts={}) click to toggle source

Enroll a user

# File lib/pandarus/v1_api.rb, line 10236
def enroll_user_courses(course_id,enrollment__user_id__,enrollment__type__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :enrollment__user_id__,
    :enrollment__type__,
    :enrollment__role__,
    :enrollment__role_id__,
    :enrollment__enrollment_state__,
    :enrollment__course_section_id__,
    :enrollment__limit_privileges_to_course_section__,
    :enrollment__notify__,
    :enrollment__self_enrollment_code__,
    :enrollment__self_enrolled__,
    :enrollment__associated_user_id__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "enrollment__user_id__ is required" if enrollment__user_id__.nil?
  raise "enrollment__type__ is required" if enrollment__type__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :enrollment__user_id__ => enrollment__user_id__,
    :enrollment__type__ => enrollment__type__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/enrollments",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Enrollment.new(response)
  

end
enroll_user_sections(section_id,enrollment__user_id__,enrollment__type__,opts={}) click to toggle source

Enroll a user

# File lib/pandarus/v1_api.rb, line 10285
def enroll_user_sections(section_id,enrollment__user_id__,enrollment__type__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :enrollment__user_id__,
    :enrollment__type__,
    :enrollment__role__,
    :enrollment__role_id__,
    :enrollment__enrollment_state__,
    :enrollment__course_section_id__,
    :enrollment__limit_privileges_to_course_section__,
    :enrollment__notify__,
    :enrollment__self_enrollment_code__,
    :enrollment__self_enrolled__,
    :enrollment__associated_user_id__,
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "enrollment__user_id__ is required" if enrollment__user_id__.nil?
  raise "enrollment__type__ is required" if enrollment__type__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :enrollment__user_id__ => enrollment__user_id__,
    :enrollment__type__ => enrollment__type__

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/enrollments",
    :section_id => section_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Enrollment.new(response)
  

end
enrollment_by_id(account_id,id,opts={}) click to toggle source

Enrollment by ID

# File lib/pandarus/v1_api.rb, line 10199
def enrollment_by_id(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/enrollments/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Enrollment.new(response)
  

end
export_content_courses(course_id,export_type,opts={}) click to toggle source

Export content

# File lib/pandarus/v1_api.rb, line 4951
def export_content_courses(course_id,export_type,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :export_type,
    :skip_notifications,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "export_type is required" if export_type.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :export_type => export_type

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_exports",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ContentExport.new(response)
  

end
export_content_groups(group_id,export_type,opts={}) click to toggle source

Export content

# File lib/pandarus/v1_api.rb, line 4989
def export_content_groups(group_id,export_type,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :export_type,
    :skip_notifications,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "export_type is required" if export_type.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :export_type => export_type

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_exports",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ContentExport.new(response)
  

end
export_content_users(user_id,export_type,opts={}) click to toggle source

Export content

# File lib/pandarus/v1_api.rb, line 5027
def export_content_users(user_id,export_type,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :export_type,
    :skip_notifications,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "export_type is required" if export_type.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :export_type => export_type

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_exports",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  ContentExport.new(response)
  

end
fetching_latest_quiz_statistics(course_id,quiz_id,opts={}) click to toggle source

Fetching the latest quiz statistics

# File lib/pandarus/v1_api.rb, line 21827
def fetching_latest_quiz_statistics(course_id,quiz_id,opts={})
  query_param_keys = [
    :all_versions

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/statistics",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
find_recipients(opts={}) click to toggle source

Find recipients

# File lib/pandarus/v1_api.rb, line 6728
def find_recipients(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/conversations/find_recipients",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
find_recipients_conversations(opts={}) click to toggle source

Find recipients

# File lib/pandarus/v1_api.rb, line 23330
def find_recipients_conversations(opts={})
  query_param_keys = [
    :search,
    :context,
    :exclude,
    :type,
    :user_id,
    :from_conversation_id,
    :permissions

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/conversations/find_recipients",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
flagging_question(quiz_submission_id,id,attempt,validation_token,opts={}) click to toggle source

Flagging a question.

# File lib/pandarus/v1_api.rb, line 22061
def flagging_question(quiz_submission_id,id,attempt,validation_token,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :attempt,
    :validation_token,
    :access_code,
    

  ]

  # verify existence of params
  raise "quiz_submission_id is required" if quiz_submission_id.nil?
  raise "id is required" if id.nil?
  raise "attempt is required" if attempt.nil?
  raise "validation_token is required" if validation_token.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :quiz_submission_id => quiz_submission_id,
    :id => id,
    :attempt => attempt,
    :validation_token => validation_token

  )

  # resource path
  path = path_replace("/v1/quiz_submissions/{quiz_submission_id}/questions/{id}/flag",
    :quiz_submission_id => quiz_submission_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
get_all_outcome_groups_for_context_accounts(account_id,opts={}) click to toggle source

Get all outcome groups for context

# File lib/pandarus/v1_api.rb, line 17269
def get_all_outcome_groups_for_context_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/outcome_groups",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, OutcomeGroup, path, query_params)
  

end
get_all_outcome_groups_for_context_courses(course_id,opts={}) click to toggle source

Get all outcome groups for context

# File lib/pandarus/v1_api.rb, line 17302
def get_all_outcome_groups_for_context_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_groups",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, OutcomeGroup, path, query_params)
  

end
get_all_peer_reviews_courses_peer_reviews(course_id,assignment_id,opts={}) click to toggle source

Get all Peer Reviews

# File lib/pandarus/v1_api.rb, line 19617
def get_all_peer_reviews_courses_peer_reviews(course_id,assignment_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/peer_reviews",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PeerReview, path, query_params)
  

end
get_all_peer_reviews_courses_submissions(course_id,assignment_id,submission_id,opts={}) click to toggle source

Get all Peer Reviews

# File lib/pandarus/v1_api.rb, line 19689
def get_all_peer_reviews_courses_submissions(course_id,assignment_id,submission_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "submission_id is required" if submission_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{submission_id}/peer_reviews",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PeerReview, path, query_params)
  

end
get_all_peer_reviews_sections_peer_reviews(section_id,assignment_id,opts={}) click to toggle source

Get all Peer Reviews

# File lib/pandarus/v1_api.rb, line 19653
def get_all_peer_reviews_sections_peer_reviews(section_id,assignment_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/peer_reviews",
    :section_id => section_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PeerReview, path, query_params)
  

end
get_all_peer_reviews_sections_submissions(section_id,assignment_id,submission_id,opts={}) click to toggle source

Get all Peer Reviews

# File lib/pandarus/v1_api.rb, line 19728
def get_all_peer_reviews_sections_submissions(section_id,assignment_id,submission_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "submission_id is required" if submission_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/{submission_id}/peer_reviews",
    :section_id => section_id,
    :assignment_id => assignment_id,
    :submission_id => submission_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PeerReview, path, query_params)
  

end
get_all_quiz_submission_questions(quiz_submission_id,opts={}) click to toggle source

Get all quiz submission questions.

# File lib/pandarus/v1_api.rb, line 21986
def get_all_quiz_submission_questions(quiz_submission_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "quiz_submission_id is required" if quiz_submission_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :quiz_submission_id => quiz_submission_id

  )

  # resource path
  path = path_replace("/v1/quiz_submissions/{quiz_submission_id}/questions",
    :quiz_submission_id => quiz_submission_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_all_quiz_submissions(course_id,quiz_id,opts={}) click to toggle source

Get all quiz submissions.

# File lib/pandarus/v1_api.rb, line 22187
def get_all_quiz_submissions(course_id,quiz_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_assignment_group(course_id,assignment_group_id,opts={}) click to toggle source

Get an Assignment Group

# File lib/pandarus/v1_api.rb, line 2052
def get_assignment_group(course_id,assignment_group_id,opts={})
  query_param_keys = [
    :include,
    :override_assignment_dates,
    :grading_period_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_group_id is required" if assignment_group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_group_id => assignment_group_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignment_groups/{assignment_group_id}",
    :course_id => course_id,
    :assignment_group_id => assignment_group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  AssignmentGroup.new(response)
  

end
get_associated_course_information(course_id,template_id,opts={}) click to toggle source

Get associated course information

# File lib/pandarus/v1_api.rb, line 3265
def get_associated_course_information(course_id,template_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}/associated_courses",
    :course_id => course_id,
    :template_id => template_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Course, path, query_params)
  

end
get_authentication_provider(account_id,id,opts={}) click to toggle source

Get authentication provider

# File lib/pandarus/v1_api.rb, line 2981
def get_authentication_provider(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/authentication_providers/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  AuthenticationProvider.new(response)
  

end
get_available_quiz_ip_filters(course_id,quiz_id,opts={}) click to toggle source

Get available quiz IP filters.

# File lib/pandarus/v1_api.rb, line 21208
def get_available_quiz_ip_filters(course_id,quiz_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/ip_filters",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_blueprint_information(course_id,template_id,opts={}) click to toggle source

Get blueprint information

# File lib/pandarus/v1_api.rb, line 3228
def get_blueprint_information(course_id,template_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}",
    :course_id => course_id,
    :template_id => template_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  BlueprintTemplate.new(response)
  

end
get_bookmark(id,opts={}) click to toggle source

Get bookmark

# File lib/pandarus/v1_api.rb, line 3756
def get_bookmark(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/self/bookmarks/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Bookmark.new(response)
  

end
get_brand_config_variables_that_should_be_used_for_this_domain(opts={}) click to toggle source

Get the brand config variables that should be used for this domain

# File lib/pandarus/v1_api.rb, line 3862
def get_brand_config_variables_that_should_be_used_for_this_domain(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/brand_variables",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_content_migration_accounts(account_id,id,opts={}) click to toggle source

Get a content migration

# File lib/pandarus/v1_api.rb, line 5673
def get_content_migration_accounts(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/content_migrations/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
get_content_migration_courses(course_id,id,opts={}) click to toggle source

Get a content migration

# File lib/pandarus/v1_api.rb, line 5710
def get_content_migration_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_migrations/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
get_content_migration_groups(group_id,id,opts={}) click to toggle source

Get a content migration

# File lib/pandarus/v1_api.rb, line 5747
def get_content_migration_groups(group_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_migrations/{id}",
    :group_id => group_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
get_content_migration_users(user_id,id,opts={}) click to toggle source

Get a content migration

# File lib/pandarus/v1_api.rb, line 5784
def get_content_migration_users(user_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_migrations/{id}",
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
get_course_copy_status(course_id,id,opts={}) click to toggle source

Get course copy status

# File lib/pandarus/v1_api.rb, line 7757
def get_course_copy_status(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/course_copy/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_course_level_assignment_data(course_id,opts={}) click to toggle source

Get course-level assignment data

# File lib/pandarus/v1_api.rb, line 1281
def get_course_level_assignment_data(course_id,opts={})
  query_param_keys = [
    :async

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/analytics/assignments",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_course_level_participation_data(course_id,opts={}) click to toggle source

Get course-level participation data

# File lib/pandarus/v1_api.rb, line 1247
def get_course_level_participation_data(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/analytics/activity",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_course_level_student_summary_data(course_id,opts={}) click to toggle source

Get course-level student summary data

# File lib/pandarus/v1_api.rb, line 1315
def get_course_level_student_summary_data(course_id,opts={})
  query_param_keys = [
    :sort_column,
    :student_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/analytics/student_summaries",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_course_nickname(course_id,opts={}) click to toggle source

Get course nickname

# File lib/pandarus/v1_api.rb, line 26318
def get_course_nickname(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/users/self/course_nicknames/{course_id}",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  CourseNickname.new(response)
  

end
get_course_settings(course_id,opts={}) click to toggle source

Get course settings

# File lib/pandarus/v1_api.rb, line 7395
def get_course_settings(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/settings",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_course_timetable(course_id,opts={}) click to toggle source

Get course timetable

# File lib/pandarus/v1_api.rb, line 4249
def get_course_timetable(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/calendar_events/timetable",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_current_quiz_submission_times(course_id,quiz_id,id,opts={}) click to toggle source

Get current quiz submission times.

# File lib/pandarus/v1_api.rb, line 22432
def get_current_quiz_submission_times(course_id,quiz_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions/{id}/time",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_custom_color(id,asset_string,opts={}) click to toggle source

Get custom color

# File lib/pandarus/v1_api.rb, line 25778
def get_custom_color(id,asset_string,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "asset_string is required" if asset_string.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :asset_string => asset_string

  )

  # resource path
  path = path_replace("/v1/users/{id}/colors/{asset_string}",
    :id => id,
    :asset_string => asset_string)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_custom_colors(id,opts={}) click to toggle source

Get custom colors

# File lib/pandarus/v1_api.rb, line 25744
def get_custom_colors(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{id}/colors",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_dashboard_postions(id,opts={}) click to toggle source

Get dashboard postions

# File lib/pandarus/v1_api.rb, line 25853
def get_dashboard_postions(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{id}/dashboard_positions",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_grade_data_completed(account_id,opts={}) click to toggle source

Get department-level grade data

# File lib/pandarus/v1_api.rb, line 1108
def get_department_level_grade_data_completed(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/completed/grades",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_grade_data_current(account_id,opts={}) click to toggle source

Get department-level grade data

# File lib/pandarus/v1_api.rb, line 1074
def get_department_level_grade_data_current(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/current/grades",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_grade_data_terms(account_id,term_id,opts={}) click to toggle source

Get department-level grade data

# File lib/pandarus/v1_api.rb, line 1037
def get_department_level_grade_data_terms(account_id,term_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "term_id is required" if term_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :term_id => term_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/terms/{term_id}/grades",
    :account_id => account_id,
    :term_id => term_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_participation_data_completed(account_id,opts={}) click to toggle source

Get department-level participation data

# File lib/pandarus/v1_api.rb, line 1003
def get_department_level_participation_data_completed(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/completed/activity",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_participation_data_current(account_id,opts={}) click to toggle source

Get department-level participation data

# File lib/pandarus/v1_api.rb, line 969
def get_department_level_participation_data_current(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/current/activity",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_participation_data_terms(account_id,term_id,opts={}) click to toggle source

Get department-level participation data

# File lib/pandarus/v1_api.rb, line 932
def get_department_level_participation_data_terms(account_id,term_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "term_id is required" if term_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :term_id => term_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/terms/{term_id}/activity",
    :account_id => account_id,
    :term_id => term_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_statistics_completed(account_id,opts={}) click to toggle source

Get department-level statistics

# File lib/pandarus/v1_api.rb, line 1213
def get_department_level_statistics_completed(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/completed/statistics",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_statistics_current(account_id,opts={}) click to toggle source

Get department-level statistics

# File lib/pandarus/v1_api.rb, line 1179
def get_department_level_statistics_current(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/current/statistics",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_department_level_statistics_terms(account_id,term_id,opts={}) click to toggle source

Get department-level statistics

# File lib/pandarus/v1_api.rb, line 1142
def get_department_level_statistics_terms(account_id,term_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "term_id is required" if term_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :term_id => term_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/analytics/terms/{term_id}/statistics",
    :account_id => account_id,
    :term_id => term_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_effective_due_dates(course_id,opts={}) click to toggle source

Get effective due dates

# File lib/pandarus/v1_api.rb, line 7689
def get_effective_due_dates(course_id,opts={})
  query_param_keys = [
    :assignment_ids

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/effective_due_dates",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_feature_flag_accounts(account_id,feature,opts={}) click to toggle source

Get feature flag

# File lib/pandarus/v1_api.rb, line 11557
def get_feature_flag_accounts(account_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/features/flags/{feature}",
    :account_id => account_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
get_feature_flag_courses(course_id,feature,opts={}) click to toggle source

Get feature flag

# File lib/pandarus/v1_api.rb, line 11520
def get_feature_flag_courses(course_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/features/flags/{feature}",
    :course_id => course_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
get_feature_flag_users(user_id,feature,opts={}) click to toggle source

Get feature flag

# File lib/pandarus/v1_api.rb, line 11594
def get_feature_flag_users(user_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/features/flags/{feature}",
    :user_id => user_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
get_file_courses(course_id,id,opts={}) click to toggle source

Get file

# File lib/pandarus/v1_api.rb, line 12178
def get_file_courses(course_id,id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/files/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  File.new(response)
  

end
get_file_files(id,opts={}) click to toggle source

Get file

# File lib/pandarus/v1_api.rb, line 12144
def get_file_files(id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/files/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  File.new(response)
  

end
get_file_groups(group_id,id,opts={}) click to toggle source

Get file

# File lib/pandarus/v1_api.rb, line 12215
def get_file_groups(group_id,id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/files/{id}",
    :group_id => group_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  File.new(response)
  

end
get_file_users(user_id,id,opts={}) click to toggle source

Get file

# File lib/pandarus/v1_api.rb, line 12252
def get_file_users(user_id,id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/files/{id}",
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  File.new(response)
  

end
get_folder_courses(course_id,id,opts={}) click to toggle source

Get folder

# File lib/pandarus/v1_api.rb, line 12694
def get_folder_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/folders/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Folder.new(response)
  

end
get_folder_folders(id,opts={}) click to toggle source

Get folder

# File lib/pandarus/v1_api.rb, line 12805
def get_folder_folders(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/folders/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Folder.new(response)
  

end
get_folder_groups(group_id,id,opts={}) click to toggle source

Get folder

# File lib/pandarus/v1_api.rb, line 12768
def get_folder_groups(group_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/folders/{id}",
    :group_id => group_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Folder.new(response)
  

end
get_folder_users(user_id,id,opts={}) click to toggle source

Get folder

# File lib/pandarus/v1_api.rb, line 12731
def get_folder_users(user_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/folders/{id}",
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Folder.new(response)
  

end
get_full_topic_courses(course_id,topic_id,opts={}) click to toggle source

Get the full topic

# File lib/pandarus/v1_api.rb, line 8766
def get_full_topic_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/view",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_full_topic_groups(group_id,topic_id,opts={}) click to toggle source

Get the full topic

# File lib/pandarus/v1_api.rb, line 8803
def get_full_topic_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/view",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_import_details(course_id,subscription_id,id,opts={}) click to toggle source

Get import details

# File lib/pandarus/v1_api.rb, line 3648
def get_import_details(course_id,subscription_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "subscription_id is required" if subscription_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :subscription_id => subscription_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_subscriptions/{subscription_id}/migrations/{id}/details",
    :course_id => course_id,
    :subscription_id => subscription_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ChangeRecord, path, query_params)
  

end
get_kaltura_config(opts={}) click to toggle source

Get Kaltura config

# File lib/pandarus/v1_api.rb, line 23732
def get_kaltura_config(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/services/kaltura",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_late_policy(id,opts={}) click to toggle source

Get a late policy

# File lib/pandarus/v1_api.rb, line 15489
def get_late_policy(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{id}/late_policy",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_migration_details(course_id,template_id,id,opts={}) click to toggle source

Get migration details

# File lib/pandarus/v1_api.rb, line 3533
def get_migration_details(course_id,template_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}/migrations/{id}/details",
    :course_id => course_id,
    :template_id => template_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ChangeRecord, path, query_params)
  

end
get_migration_issue_accounts(account_id,content_migration_id,id,opts={}) click to toggle source

Get a migration issue

# File lib/pandarus/v1_api.rb, line 5209
def get_migration_issue_accounts(account_id,content_migration_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :content_migration_id => content_migration_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/content_migrations/{content_migration_id}/migration_issues/{id}",
    :account_id => account_id,
    :content_migration_id => content_migration_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  MigrationIssue.new(response)
  

end
get_migration_issue_courses(course_id,content_migration_id,id,opts={}) click to toggle source

Get a migration issue

# File lib/pandarus/v1_api.rb, line 5249
def get_migration_issue_courses(course_id,content_migration_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :content_migration_id => content_migration_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_migrations/{content_migration_id}/migration_issues/{id}",
    :course_id => course_id,
    :content_migration_id => content_migration_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  MigrationIssue.new(response)
  

end
get_migration_issue_groups(group_id,content_migration_id,id,opts={}) click to toggle source

Get a migration issue

# File lib/pandarus/v1_api.rb, line 5289
def get_migration_issue_groups(group_id,content_migration_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :content_migration_id => content_migration_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_migrations/{content_migration_id}/migration_issues/{id}",
    :group_id => group_id,
    :content_migration_id => content_migration_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  MigrationIssue.new(response)
  

end
get_migration_issue_users(user_id,content_migration_id,id,opts={}) click to toggle source

Get a migration issue

# File lib/pandarus/v1_api.rb, line 5329
def get_migration_issue_users(user_id,content_migration_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :content_migration_id => content_migration_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_migrations/{content_migration_id}/migration_issues/{id}",
    :user_id => user_id,
    :content_migration_id => content_migration_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  MigrationIssue.new(response)
  

end
get_module_item_sequence(course_id,opts={}) click to toggle source

Get module item sequence

# File lib/pandarus/v1_api.rb, line 16698
def get_module_item_sequence(course_id,opts={})
  query_param_keys = [
    :asset_type,
    :asset_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/module_item_sequence",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ModuleItemSequence.new(response)
  

end
get_next_appointment(opts={}) click to toggle source

Get next appointment

# File lib/pandarus/v1_api.rb, line 1983
def get_next_appointment(opts={})
  query_param_keys = [
    :appointment_group_ids

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/appointment_groups/next_appointment",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CalendarEvent, path, query_params)
  

end
get_outcome_result_rollups(course_id,opts={}) click to toggle source

Get outcome result rollups

# File lib/pandarus/v1_api.rb, line 18624
def get_outcome_result_rollups(course_id,opts={})
  query_param_keys = [
    :aggregate,
    :user_ids,
    :outcome_ids,
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_rollups",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_outcome_results(course_id,opts={}) click to toggle source

Get outcome results

# File lib/pandarus/v1_api.rb, line 18588
def get_outcome_results(course_id,opts={})
  query_param_keys = [
    :user_ids,
    :outcome_ids,
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_results",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_preference_communication_channel_id(user_id,communication_channel_id,notification,opts={}) click to toggle source

Get a preference

# File lib/pandarus/v1_api.rb, line 16885
def get_preference_communication_channel_id(user_id,communication_channel_id,notification,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "communication_channel_id is required" if communication_channel_id.nil?
  raise "notification is required" if notification.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :communication_channel_id => communication_channel_id,
    :notification => notification

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels/{communication_channel_id}/notification_preferences/{notification}",
    :user_id => user_id,
    :communication_channel_id => communication_channel_id,
    :notification => notification)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  NotificationPreference.new(response)
  

end
get_preference_type(user_id,type,address,notification,opts={}) click to toggle source

Get a preference

# File lib/pandarus/v1_api.rb, line 16925
def get_preference_type(user_id,type,address,notification,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "type is required" if type.nil?
  raise "address is required" if address.nil?
  raise "notification is required" if notification.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :type => type,
    :address => address,
    :notification => notification

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels/{type}/{address}/notification_preferences/{notification}",
    :user_id => user_id,
    :type => type,
    :address => address,
    :notification => notification)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  NotificationPreference.new(response)
  

end
get_public_inline_preview_url(id,opts={}) click to toggle source

Get public inline preview url

# File lib/pandarus/v1_api.rb, line 12110
def get_public_inline_preview_url(id,opts={})
  query_param_keys = [
    :submission_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/files/{id}/public_url",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_quiz_report(course_id,quiz_id,id,opts={}) click to toggle source

Get a quiz report

# File lib/pandarus/v1_api.rb, line 21747
def get_quiz_report(course_id,quiz_id,id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/reports/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  QuizReport.new(response)
  

end
get_quiz_submission(course_id,quiz_id,opts={}) click to toggle source

Get the quiz submission.

# File lib/pandarus/v1_api.rb, line 22224
def get_quiz_submission(course_id,quiz_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submission",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_quota_information_courses(course_id,opts={}) click to toggle source

Get quota information

# File lib/pandarus/v1_api.rb, line 11856
def get_quota_information_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/files/quota",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_quota_information_groups(group_id,opts={}) click to toggle source

Get quota information

# File lib/pandarus/v1_api.rb, line 11890
def get_quota_information_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/files/quota",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_quota_information_users(user_id,opts={}) click to toggle source

Get quota information

# File lib/pandarus/v1_api.rb, line 11924
def get_quota_information_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/files/quota",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_results_for_single_poll_session(poll_id,id,opts={}) click to toggle source

Get the results for a single poll session

# File lib/pandarus/v1_api.rb, line 20358
def get_results_for_single_poll_session(poll_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions/{id}",
    :poll_id => poll_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_running_batches(opts={}) click to toggle source

Get running batches

# File lib/pandarus/v1_api.rb, line 6395
def get_running_batches(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/conversations/batches",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_section_information_courses(course_id,id,opts={}) click to toggle source

Get section information

# File lib/pandarus/v1_api.rb, line 23627
def get_section_information_courses(course_id,id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/sections/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Section.new(response)
  

end
get_section_information_sections(id,opts={}) click to toggle source

Get section information

# File lib/pandarus/v1_api.rb, line 23664
def get_section_information_sections(id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/sections/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Section.new(response)
  

end
get_sessionless_launch_url_for_external_tool_accounts(account_id,opts={}) click to toggle source

Get a sessionless launch url for an external tool.

# File lib/pandarus/v1_api.rb, line 10593
def get_sessionless_launch_url_for_external_tool_accounts(account_id,opts={})
  query_param_keys = [
    :id,
    :url,
    :assignment_id,
    :module_item_id,
    :launch_type

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/external_tools/sessionless_launch",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_sessionless_launch_url_for_external_tool_courses(course_id,opts={}) click to toggle source

Get a sessionless launch url for an external tool.

# File lib/pandarus/v1_api.rb, line 10555
def get_sessionless_launch_url_for_external_tool_courses(course_id,opts={})
  query_param_keys = [
    :id,
    :url,
    :assignment_id,
    :module_item_id,
    :launch_type

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_tools/sessionless_launch",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_account(id,opts={}) click to toggle source

Get a single account

# File lib/pandarus/v1_api.rb, line 508
def get_single_account(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Account.new(response)
  

end
get_single_appointment_group(id,opts={}) click to toggle source

Get a single appointment group

# File lib/pandarus/v1_api.rb, line 1799
def get_single_appointment_group(id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/appointment_groups/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_assignment(course_id,id,opts={}) click to toggle source

Get a single assignment

# File lib/pandarus/v1_api.rb, line 2318
def get_single_assignment(course_id,id,opts={})
  query_param_keys = [
    :include,
    :override_assignment_dates,
    :needs_grading_count_by_section,
    :all_dates

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Assignment.new(response)
  

end
get_single_assignment_override(course_id,assignment_id,id,opts={}) click to toggle source

Get a single assignment override

# File lib/pandarus/v1_api.rb, line 2524
def get_single_assignment_override(course_id,assignment_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/overrides/{id}",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  AssignmentOverride.new(response)
  

end
get_single_calendar_event_or_assignment(id,opts={}) click to toggle source

Get a single calendar event or assignment

# File lib/pandarus/v1_api.rb, line 4021
def get_single_calendar_event_or_assignment(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/calendar_events/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  CalendarEvent.new(response)
  

end
get_single_conversation(id,opts={}) click to toggle source

Get a single conversation

# File lib/pandarus/v1_api.rb, line 6428
def get_single_conversation(id,opts={})
  query_param_keys = [
    :interleave_submissions,
    :scope,
    :filter,
    :filter_mode,
    :auto_mark_as_read

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/conversations/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_course_accounts(account_id,id,opts={}) click to toggle source

Get a single course

# File lib/pandarus/v1_api.rb, line 7508
def get_single_course_accounts(account_id,id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/courses/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Course.new(response)
  

end
get_single_course_courses(id,opts={}) click to toggle source

Get a single course

# File lib/pandarus/v1_api.rb, line 7474
def get_single_course_courses(id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Course.new(response)
  

end
get_single_external_tool_accounts(account_id,external_tool_id,opts={}) click to toggle source

Get a single external tool

# File lib/pandarus/v1_api.rb, line 10668
def get_single_external_tool_accounts(account_id,external_tool_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "external_tool_id is required" if external_tool_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :external_tool_id => external_tool_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/external_tools/{external_tool_id}",
    :account_id => account_id,
    :external_tool_id => external_tool_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_external_tool_courses(course_id,external_tool_id,opts={}) click to toggle source

Get a single external tool

# File lib/pandarus/v1_api.rb, line 10631
def get_single_external_tool_courses(course_id,external_tool_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "external_tool_id is required" if external_tool_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :external_tool_id => external_tool_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_tools/{external_tool_id}",
    :course_id => course_id,
    :external_tool_id => external_tool_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_grading_period(course_id,id,opts={}) click to toggle source

Get a single grading period

# File lib/pandarus/v1_api.rb, line 13891
def get_single_grading_period(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/grading_periods/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_grading_standard_in_context_accounts(account_id,grading_standard_id,opts={}) click to toggle source

Get a single grading standard in a context.

# File lib/pandarus/v1_api.rb, line 14235
def get_single_grading_standard_in_context_accounts(account_id,grading_standard_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "grading_standard_id is required" if grading_standard_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :grading_standard_id => grading_standard_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/grading_standards/{grading_standard_id}",
    :account_id => account_id,
    :grading_standard_id => grading_standard_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  GradingStandard.new(response)
  

end
get_single_grading_standard_in_context_courses(course_id,grading_standard_id,opts={}) click to toggle source

Get a single grading standard in a context.

# File lib/pandarus/v1_api.rb, line 14198
def get_single_grading_standard_in_context_courses(course_id,grading_standard_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "grading_standard_id is required" if grading_standard_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :grading_standard_id => grading_standard_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/grading_standards/{grading_standard_id}",
    :course_id => course_id,
    :grading_standard_id => grading_standard_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  GradingStandard.new(response)
  

end
get_single_group(group_id,opts={}) click to toggle source

Get a single group

# File lib/pandarus/v1_api.rb, line 14733
def get_single_group(group_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Group.new(response)
  

end
get_single_group_category(group_category_id,opts={}) click to toggle source

Get a single group category

# File lib/pandarus/v1_api.rb, line 14338
def get_single_group_category(group_category_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_category_id is required" if group_category_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_category_id => group_category_id

  )

  # resource path
  path = path_replace("/v1/group_categories/{group_category_id}",
    :group_category_id => group_category_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  GroupCategory.new(response)
  

end
get_single_group_membership_memberships(group_id,membership_id,opts={}) click to toggle source

Get a single group membership

# File lib/pandarus/v1_api.rb, line 15160
def get_single_group_membership_memberships(group_id,membership_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "membership_id is required" if membership_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :membership_id => membership_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/memberships/{membership_id}",
    :group_id => group_id,
    :membership_id => membership_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  GroupMembership.new(response)
  

end
get_single_group_membership_users(group_id,user_id,opts={}) click to toggle source

Get a single group membership

# File lib/pandarus/v1_api.rb, line 15197
def get_single_group_membership_users(group_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/users/{user_id}",
    :group_id => group_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  GroupMembership.new(response)
  

end
get_single_poll(id,opts={}) click to toggle source

Get a single poll

# File lib/pandarus/v1_api.rb, line 20953
def get_single_poll(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_poll_choice(poll_id,id,opts={}) click to toggle source

Get a single poll choice

# File lib/pandarus/v1_api.rb, line 20685
def get_single_poll_choice(poll_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_choices/{id}",
    :poll_id => poll_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_poll_submission(poll_id,poll_session_id,id,opts={}) click to toggle source

Get a single poll submission

# File lib/pandarus/v1_api.rb, line 20840
def get_single_poll_submission(poll_id,poll_session_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "poll_session_id is required" if poll_session_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :poll_session_id => poll_session_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions/{poll_session_id}/poll_submissions/{id}",
    :poll_id => poll_id,
    :poll_session_id => poll_session_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_quiz(course_id,id,opts={}) click to toggle source

Get a single quiz

# File lib/pandarus/v1_api.rb, line 22505
def get_single_quiz(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Quiz.new(response)
  

end
get_single_quiz_group(course_id,quiz_id,id,opts={}) click to toggle source

Get a single quiz group

# File lib/pandarus/v1_api.rb, line 21245
def get_single_quiz_group(course_id,quiz_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/groups/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  QuizGroup.new(response)
  

end
get_single_quiz_question(course_id,quiz_id,id,opts={}) click to toggle source

Get a single quiz question

# File lib/pandarus/v1_api.rb, line 21490
def get_single_quiz_question(course_id,quiz_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/questions/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  QuizQuestion.new(response)
  

end
get_single_quiz_submission(course_id,quiz_id,id,opts={}) click to toggle source

Get a single quiz submission.

# File lib/pandarus/v1_api.rb, line 22261
def get_single_quiz_submission(course_id,quiz_id,id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_role(id,account_id,role_id,opts={}) click to toggle source

Get a single role

# File lib/pandarus/v1_api.rb, line 22791
def get_single_role(id,account_id,role_id,opts={})
  query_param_keys = [
    :role_id,
    :role

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "account_id is required" if account_id.nil?
  raise "role_id is required" if role_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :account_id => account_id,
    :role_id => role_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/roles/{id}",
    :id => id,
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Role.new(response)
  

end
get_single_rubric_accounts(account_id,id,opts={}) click to toggle source

Get a single rubric

# File lib/pandarus/v1_api.rb, line 23066
def get_single_rubric_accounts(account_id,id,opts={})
  query_param_keys = [
    :include,
    :style

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/rubrics/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Rubric.new(response)
  

end
get_single_rubric_courses(course_id,id,opts={}) click to toggle source

Get a single rubric

# File lib/pandarus/v1_api.rb, line 23104
def get_single_rubric_courses(course_id,id,opts={})
  query_param_keys = [
    :include,
    :style

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/rubrics/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Rubric.new(response)
  

end
get_single_submission_courses(course_id,assignment_id,user_id,opts={}) click to toggle source

Get a single submission

# File lib/pandarus/v1_api.rb, line 24201
def get_single_submission_courses(course_id,assignment_id,user_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{user_id}",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_submission_sections(section_id,assignment_id,user_id,opts={}) click to toggle source

Get a single submission

# File lib/pandarus/v1_api.rb, line 24241
def get_single_submission_sections(section_id,assignment_id,user_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/{user_id}",
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_topic_courses(course_id,topic_id,opts={}) click to toggle source

Get a single topic

# File lib/pandarus/v1_api.rb, line 8692
def get_single_topic_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_topic_groups(group_id,topic_id,opts={}) click to toggle source

Get a single topic

# File lib/pandarus/v1_api.rb, line 8729
def get_single_topic_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_single_user(course_id,id,opts={}) click to toggle source

Get single user

# File lib/pandarus/v1_api.rb, line 7185
def get_single_user(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/users/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  User.new(response)
  

end
get_sis_import_list(account_id,opts={}) click to toggle source

Get SIS import list

# File lib/pandarus/v1_api.rb, line 23142
def get_sis_import_list(account_id,opts={})
  query_param_keys = [
    :created_since

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sis_imports",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, SisImport, path, query_params)
  

end
get_sis_import_status(account_id,id,opts={}) click to toggle source

Get SIS import status

# File lib/pandarus/v1_api.rb, line 23222
def get_sis_import_status(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sis_imports/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  SisImport.new(response)
  

end
get_sub_accounts_of_account(account_id,opts={}) click to toggle source

Get the sub-accounts of an account

# File lib/pandarus/v1_api.rb, line 542
def get_sub_accounts_of_account(account_id,opts={})
  query_param_keys = [
    :recursive

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sub_accounts",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Account, path, query_params)
  

end
get_unsynced_changes(course_id,template_id,opts={}) click to toggle source

Get unsynced changes

# File lib/pandarus/v1_api.rb, line 3421
def get_unsynced_changes(course_id,template_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}/unsynced_changes",
    :course_id => course_id,
    :template_id => template_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ChangeRecord, path, query_params)
  

end
get_user_in_a_course_level_assignment_data(course_id,student_id,opts={}) click to toggle source

Get user-in-a-course-level assignment data

# File lib/pandarus/v1_api.rb, line 1387
def get_user_in_a_course_level_assignment_data(course_id,student_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "student_id is required" if student_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :student_id => student_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/analytics/users/{student_id}/assignments",
    :course_id => course_id,
    :student_id => student_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_user_in_a_course_level_messaging_data(course_id,student_id,opts={}) click to toggle source

Get user-in-a-course-level messaging data

# File lib/pandarus/v1_api.rb, line 1424
def get_user_in_a_course_level_messaging_data(course_id,student_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "student_id is required" if student_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :student_id => student_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/analytics/users/{student_id}/communication",
    :course_id => course_id,
    :student_id => student_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_user_in_a_course_level_participation_data(course_id,student_id,opts={}) click to toggle source

Get user-in-a-course-level participation data

# File lib/pandarus/v1_api.rb, line 1350
def get_user_in_a_course_level_participation_data(course_id,student_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "student_id is required" if student_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :student_id => student_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/analytics/users/{student_id}/activity",
    :course_id => course_id,
    :student_id => student_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
get_user_profile(user_id,opts={}) click to toggle source

Get user profile

# File lib/pandarus/v1_api.rb, line 26073
def get_user_profile(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/profile",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Profile.new(response)
  

end
grade_or_comment_on_multiple_submissions_courses_assignments(course_id,assignment_id,opts={}) click to toggle source

Grade or comment on multiple submissions

# File lib/pandarus/v1_api.rb, line 24577
def grade_or_comment_on_multiple_submissions_courses_assignments(course_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :grade_data___student_id_____posted_grade__,
    :grade_data___student_id_____excuse__,
    :grade_data___student_id_____rubric_assessment__,
    :grade_data___student_id_____text_comment__,
    :grade_data___student_id_____group_comment__,
    :grade_data___student_id_____media_comment_id__,
    :grade_data___student_id_____media_comment_type__,
    :grade_data___student_id_____file_ids__,
    :grade_data___student_id_____assignment_id__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/update_grades",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Progress.new(response)
  

end
grade_or_comment_on_multiple_submissions_courses_submissions(course_id,opts={}) click to toggle source

Grade or comment on multiple submissions

# File lib/pandarus/v1_api.rb, line 24534
def grade_or_comment_on_multiple_submissions_courses_submissions(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :grade_data___student_id_____posted_grade__,
    :grade_data___student_id_____excuse__,
    :grade_data___student_id_____rubric_assessment__,
    :grade_data___student_id_____text_comment__,
    :grade_data___student_id_____group_comment__,
    :grade_data___student_id_____media_comment_id__,
    :grade_data___student_id_____media_comment_type__,
    :grade_data___student_id_____file_ids__,
    :grade_data___student_id_____assignment_id__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/submissions/update_grades",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Progress.new(response)
  

end
grade_or_comment_on_multiple_submissions_sections_assignments(section_id,assignment_id,opts={}) click to toggle source

Grade or comment on multiple submissions

# File lib/pandarus/v1_api.rb, line 24666
def grade_or_comment_on_multiple_submissions_sections_assignments(section_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :grade_data___student_id_____posted_grade__,
    :grade_data___student_id_____excuse__,
    :grade_data___student_id_____rubric_assessment__,
    :grade_data___student_id_____text_comment__,
    :grade_data___student_id_____group_comment__,
    :grade_data___student_id_____media_comment_id__,
    :grade_data___student_id_____media_comment_type__,
    :grade_data___student_id_____file_ids__,
    :grade_data___student_id_____assignment_id__,
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/update_grades",
    :section_id => section_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Progress.new(response)
  

end
grade_or_comment_on_multiple_submissions_sections_submissions(section_id,opts={}) click to toggle source

Grade or comment on multiple submissions

# File lib/pandarus/v1_api.rb, line 24623
def grade_or_comment_on_multiple_submissions_sections_submissions(section_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :grade_data___student_id_____posted_grade__,
    :grade_data___student_id_____excuse__,
    :grade_data___student_id_____rubric_assessment__,
    :grade_data___student_id_____text_comment__,
    :grade_data___student_id_____group_comment__,
    :grade_data___student_id_____media_comment_id__,
    :grade_data___student_id_____media_comment_type__,
    :grade_data___student_id_____file_ids__,
    :grade_data___student_id_____assignment_id__,
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/submissions/update_grades",
    :section_id => section_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Progress.new(response)
  

end
grade_or_comment_on_submission_courses(course_id,assignment_id,user_id,opts={}) click to toggle source

Grade or comment on a submission

# File lib/pandarus/v1_api.rb, line 24361
def grade_or_comment_on_submission_courses(course_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :comment__text_comment__,
    :comment__group_comment__,
    :comment__media_comment_id__,
    :comment__media_comment_type__,
    :comment__file_ids__,
    :include__visibility__,
    :submission__posted_grade__,
    :submission__excuse__,
    :submission__late_policy_status__,
    :submission__seconds_late_override__,
    :rubric_assessment,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{user_id}",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
grade_or_comment_on_submission_sections(section_id,assignment_id,user_id,opts={}) click to toggle source

Grade or comment on a submission

# File lib/pandarus/v1_api.rb, line 24412
def grade_or_comment_on_submission_sections(section_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :comment__text_comment__,
    :comment__group_comment__,
    :comment__media_comment_id__,
    :comment__media_comment_type__,
    :comment__file_ids__,
    :include__visibility__,
    :submission__posted_grade__,
    :submission__excuse__,
    :submission__late_policy_status__,
    :submission__seconds_late_override__,
    :rubric_assessment,
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/{user_id}",
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
group_activity_stream(group_id,opts={}) click to toggle source

Group activity stream

# File lib/pandarus/v1_api.rb, line 15059
def group_activity_stream(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/activity_stream",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
group_activity_stream_summary(group_id,opts={}) click to toggle source

Group activity stream summary

# File lib/pandarus/v1_api.rb, line 15093
def group_activity_stream_summary(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/activity_stream/summary",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
hide_all_stream_items(opts={}) click to toggle source

Hide all stream items

# File lib/pandarus/v1_api.rb, line 25501
def hide_all_stream_items(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/activity_stream",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
hide_stream_item(id,opts={}) click to toggle source

Hide a stream item

# File lib/pandarus/v1_api.rb, line 25467
def hide_stream_item(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/self/activity_stream/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
import_outcome_group_accounts(account_id,id,source_outcome_group_id,opts={}) click to toggle source

Import an outcome group

# File lib/pandarus/v1_api.rb, line 18508
def import_outcome_group_accounts(account_id,id,source_outcome_group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :source_outcome_group_id,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  raise "source_outcome_group_id is required" if source_outcome_group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id,
    :source_outcome_group_id => source_outcome_group_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/outcome_groups/{id}/import",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
import_outcome_group_courses(course_id,id,source_outcome_group_id,opts={}) click to toggle source

Import an outcome group

# File lib/pandarus/v1_api.rb, line 18548
def import_outcome_group_courses(course_id,id,source_outcome_group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :source_outcome_group_id,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  raise "source_outcome_group_id is required" if source_outcome_group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id,
    :source_outcome_group_id => source_outcome_group_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_groups/{id}/import",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
import_outcome_group_global(id,source_outcome_group_id,opts={}) click to toggle source

Import an outcome group

# File lib/pandarus/v1_api.rb, line 18471
def import_outcome_group_global(id,source_outcome_group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :source_outcome_group_id,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "source_outcome_group_id is required" if source_outcome_group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :source_outcome_group_id => source_outcome_group_id

  )

  # resource path
  path = path_replace("/v1/global/outcome_groups/{id}/import",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
import_sis_data(account_id,opts={}) click to toggle source

Import SIS data

# File lib/pandarus/v1_api.rb, line 23175
def import_sis_data(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :import_type,
    :attachment,
    :extension,
    :batch_mode,
    :batch_mode_term_id,
    :multi_term_batch_mode,
    :override_sis_stickiness,
    :add_sis_stickiness,
    :clear_sis_stickiness,
    :diffing_data_set_identifier,
    :diffing_remaster_data_set,
    :diffing_drop_status,
    :change_threshold,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sis_imports",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  SisImport.new(response)
  

end
index_of_active_global_notification_for_user(account_id,user_id,opts={}) click to toggle source

Index of active global notification for the user

# File lib/pandarus/v1_api.rb, line 49
def index_of_active_global_notification_for_user(account_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/users/{user_id}/account_notifications",
    :account_id => account_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, AccountNotification, path, query_params)
  

end
index_of_reports(account_id,report,opts={}) click to toggle source

Index of Reports

# File lib/pandarus/v1_api.rb, line 328
def index_of_reports(account_id,report,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "report is required" if report.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :report => report

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/reports/{report}",
    :account_id => account_id,
    :report => report)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Report, path, query_params)
  

end
invite_others_to_group(group_id,invitees,opts={}) click to toggle source

Invite others to a group

# File lib/pandarus/v1_api.rb, line 14919
def invite_others_to_group(group_id,invitees,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :invitees,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "invitees is required" if invitees.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :invitees => invitees

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/invite",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
leave_group_memberships(group_id,membership_id,opts={}) click to toggle source

Leave a group

# File lib/pandarus/v1_api.rb, line 15347
def leave_group_memberships(group_id,membership_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "membership_id is required" if membership_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :membership_id => membership_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/memberships/{membership_id}",
    :group_id => group_id,
    :membership_id => membership_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
leave_group_users(group_id,user_id,opts={}) click to toggle source

Leave a group

# File lib/pandarus/v1_api.rb, line 15384
def leave_group_users(group_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/users/{user_id}",
    :group_id => group_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
list_account_admins(account_id,opts={}) click to toggle source

List account admins

# File lib/pandarus/v1_api.rb, line 899
def list_account_admins(account_id,opts={})
  query_param_keys = [
    :user_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/admins",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Admin, path, query_params)
  

end
list_accounts(opts={}) click to toggle source

List accounts

# File lib/pandarus/v1_api.rb, line 444
def list_accounts(opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/accounts",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Account, path, query_params)
  

end
list_accounts_for_course_admins(opts={}) click to toggle source

List accounts for course admins

# File lib/pandarus/v1_api.rb, line 476
def list_accounts_for_course_admins(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/course_accounts",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Account, path, query_params)
  

end
list_active_courses_in_account(account_id,opts={}) click to toggle source

List active courses in an account

# File lib/pandarus/v1_api.rb, line 609
def list_active_courses_in_account(account_id,opts={})
  query_param_keys = [
    :with_enrollments,
    :enrollment_type,
    :published,
    :completed,
    :blueprint,
    :blueprint_associated,
    :by_teachers,
    :by_subaccounts,
    :hide_enrollmentless_courses,
    :state,
    :enrollment_term_id,
    :search_term,
    :include,
    :sort,
    :order,
    :search_by

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/courses",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Course, path, query_params)
  

end
list_activity_stream_activity_stream(opts={}) click to toggle source

List the activity stream

# File lib/pandarus/v1_api.rb, line 25302
def list_activity_stream_activity_stream(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/activity_stream",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_activity_stream_self(opts={}) click to toggle source

List the activity stream

# File lib/pandarus/v1_api.rb, line 25269
def list_activity_stream_self(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/activity_stream",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_all_courses(opts={}) click to toggle source

List all courses

# File lib/pandarus/v1_api.rb, line 23408
def list_all_courses(opts={})
  query_param_keys = [
    :search,
    :public_only,
    :open_enrollment_only

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/search/all_courses",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_all_folders_courses(course_id,opts={}) click to toggle source

List all folders

# File lib/pandarus/v1_api.rb, line 12397
def list_all_folders_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/folders",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
list_all_folders_groups(group_id,opts={}) click to toggle source

List all folders

# File lib/pandarus/v1_api.rb, line 12463
def list_all_folders_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/folders",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
list_all_folders_users(user_id,opts={}) click to toggle source

List all folders

# File lib/pandarus/v1_api.rb, line 12430
def list_all_folders_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/folders",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
list_announcements(context_codes,opts={}) click to toggle source

List announcements

# File lib/pandarus/v1_api.rb, line 1679
def list_announcements(context_codes,opts={})
  query_param_keys = [
    :context_codes,
    :start_date,
    :end_date,
    :active_only

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "context_codes is required" if context_codes.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :context_codes => context_codes

  )

  # resource path
  path = path_replace("/v1/announcements",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, DiscussionTopic, path, query_params)
  

end
list_appointment_groups(opts={}) click to toggle source

List appointment groups

# File lib/pandarus/v1_api.rb, line 1715
def list_appointment_groups(opts={})
  query_param_keys = [
    :scope,
    :context_codes,
    :include_past_appointments,
    :include

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/appointment_groups",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_assignment_groups(course_id,opts={}) click to toggle source

List assignment groups

# File lib/pandarus/v1_api.rb, line 2015
def list_assignment_groups(course_id,opts={})
  query_param_keys = [
    :include,
    :exclude_assignment_submission_types,
    :override_assignment_dates,
    :grading_period_id,
    :scope_assignments_to_student

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignment_groups",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, AssignmentGroup, path, query_params)
  

end
list_assignment_overrides(course_id,assignment_id,opts={}) click to toggle source

List assignment overrides

# File lib/pandarus/v1_api.rb, line 2488
def list_assignment_overrides(course_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/overrides",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, AssignmentOverride, path, query_params)
  

end
list_assignment_submissions_courses(course_id,assignment_id,opts={}) click to toggle source

List assignment submissions

# File lib/pandarus/v1_api.rb, line 24041
def list_assignment_submissions_courses(course_id,assignment_id,opts={})
  query_param_keys = [
    :include,
    :grouped

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Submission, path, query_params)
  

end
list_assignment_submissions_sections(section_id,assignment_id,opts={}) click to toggle source

List assignment submissions

# File lib/pandarus/v1_api.rb, line 24078
def list_assignment_submissions_sections(section_id,assignment_id,opts={})
  query_param_keys = [
    :include,
    :grouped

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions",
    :section_id => section_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Submission, path, query_params)
  

end
list_assignments(course_id,opts={}) click to toggle source

List assignments

# File lib/pandarus/v1_api.rb, line 2242
def list_assignments(course_id,opts={})
  query_param_keys = [
    :include,
    :search_term,
    :override_assignment_dates,
    :needs_grading_count_by_section,
    :bucket,
    :assignment_ids,
    :order_by

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Assignment, path, query_params)
  

end
list_assignments_for_user(user_id,course_id,opts={}) click to toggle source

List assignments for user

# File lib/pandarus/v1_api.rb, line 2281
def list_assignments_for_user(user_id,course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/courses/{course_id}/assignments",
    :user_id => user_id,
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_authentication_providers(account_id,opts={}) click to toggle source

List authentication providers

# File lib/pandarus/v1_api.rb, line 2877
def list_authentication_providers(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/authentication_providers",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, AuthenticationProvider, path, query_params)
  

end
list_available_reports(account_id,opts={}) click to toggle source

List Available Reports

# File lib/pandarus/v1_api.rb, line 256
def list_available_reports(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/reports",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_available_tabs_for_course_or_group_courses(course_id,opts={}) click to toggle source

List available tabs for a course or group

# File lib/pandarus/v1_api.rb, line 24946
def list_available_tabs_for_course_or_group_courses(course_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/tabs",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_available_tabs_for_course_or_group_groups(group_id,opts={}) click to toggle source

List available tabs for a course or group

# File lib/pandarus/v1_api.rb, line 24980
def list_available_tabs_for_course_or_group_groups(group_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/tabs",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_avatar_options(user_id,opts={}) click to toggle source

List avatar options

# File lib/pandarus/v1_api.rb, line 26107
def list_avatar_options(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/avatars",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Avatar, path, query_params)
  

end
list_blueprint_imports(course_id,subscription_id,opts={}) click to toggle source

List blueprint imports

# File lib/pandarus/v1_api.rb, line 3572
def list_blueprint_imports(course_id,subscription_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "subscription_id is required" if subscription_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :subscription_id => subscription_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_subscriptions/{subscription_id}/migrations",
    :course_id => course_id,
    :subscription_id => subscription_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, BlueprintMigration, path, query_params)
  

end
list_blueprint_migrations(course_id,template_id,opts={}) click to toggle source

List blueprint migrations

# File lib/pandarus/v1_api.rb, line 3457
def list_blueprint_migrations(course_id,template_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}/migrations",
    :course_id => course_id,
    :template_id => template_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, BlueprintMigration, path, query_params)
  

end
list_bookmarks(opts={}) click to toggle source

List bookmarks

# File lib/pandarus/v1_api.rb, line 3687
def list_bookmarks(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/bookmarks",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Bookmark, path, query_params)
  

end
list_calendar_events(opts={}) click to toggle source

List calendar events

# File lib/pandarus/v1_api.rb, line 3895
def list_calendar_events(opts={})
  query_param_keys = [
    :type,
    :start_date,
    :end_date,
    :undated,
    :all_events,
    :context_codes,
    :excludes

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/calendar_events",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CalendarEvent, path, query_params)
  

end
list_calendar_events_for_user(user_id,opts={}) click to toggle source

List calendar events for a user

# File lib/pandarus/v1_api.rb, line 3933
def list_calendar_events_for_user(user_id,opts={})
  query_param_keys = [
    :type,
    :start_date,
    :end_date,
    :undated,
    :all_events,
    :context_codes,
    :excludes

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/calendar_events",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CalendarEvent, path, query_params)
  

end
list_closed_poll_sessions(opts={}) click to toggle source

List closed poll sessions

# File lib/pandarus/v1_api.rb, line 20618
def list_closed_poll_sessions(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/poll_sessions/closed",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_collaborations_courses(course_id,opts={}) click to toggle source

List collaborations

# File lib/pandarus/v1_api.rb, line 4323
def list_collaborations_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/collaborations",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Collaboration, path, query_params)
  

end
list_collaborations_groups(group_id,opts={}) click to toggle source

List collaborations

# File lib/pandarus/v1_api.rb, line 4356
def list_collaborations_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/collaborations",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Collaboration, path, query_params)
  

end
list_conferences_courses(course_id,opts={}) click to toggle source

List conferences

# File lib/pandarus/v1_api.rb, line 4675
def list_conferences_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/conferences",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Conference, path, query_params)
  

end
list_conferences_groups(group_id,opts={}) click to toggle source

List conferences

# File lib/pandarus/v1_api.rb, line 4708
def list_conferences_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/conferences",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Conference, path, query_params)
  

end
list_content_exports_courses(course_id,opts={}) click to toggle source

List content exports

# File lib/pandarus/v1_api.rb, line 4741
def list_content_exports_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_exports",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ContentExport, path, query_params)
  

end
list_content_exports_groups(group_id,opts={}) click to toggle source

List content exports

# File lib/pandarus/v1_api.rb, line 4774
def list_content_exports_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_exports",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ContentExport, path, query_params)
  

end
list_content_exports_users(user_id,opts={}) click to toggle source

List content exports

# File lib/pandarus/v1_api.rb, line 4807
def list_content_exports_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_exports",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ContentExport, path, query_params)
  

end
list_content_migrations_accounts(account_id,opts={}) click to toggle source

List content migrations

# File lib/pandarus/v1_api.rb, line 5541
def list_content_migrations_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/content_migrations",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ContentMigration, path, query_params)
  

end
list_content_migrations_courses(course_id,opts={}) click to toggle source

List content migrations

# File lib/pandarus/v1_api.rb, line 5574
def list_content_migrations_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_migrations",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ContentMigration, path, query_params)
  

end
list_content_migrations_groups(group_id,opts={}) click to toggle source

List content migrations

# File lib/pandarus/v1_api.rb, line 5607
def list_content_migrations_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_migrations",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ContentMigration, path, query_params)
  

end
list_content_migrations_users(user_id,opts={}) click to toggle source

List content migrations

# File lib/pandarus/v1_api.rb, line 5640
def list_content_migrations_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_migrations",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ContentMigration, path, query_params)
  

end
list_conversations(opts={}) click to toggle source

List conversations

# File lib/pandarus/v1_api.rb, line 6309
def list_conversations(opts={})
  query_param_keys = [
    :scope,
    :filter,
    :filter_mode,
    :interleave_submissions,
    :include_all_conversation_ids,
    :include

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/conversations",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Conversation, path, query_params)
  

end
list_course_nicknames(opts={}) click to toggle source

List course nicknames

# File lib/pandarus/v1_api.rb, line 26286
def list_course_nicknames(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/course_nicknames",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CourseNickname, path, query_params)
  

end
list_course_sections(course_id,opts={}) click to toggle source

List course sections

# File lib/pandarus/v1_api.rb, line 23443
def list_course_sections(course_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/sections",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Section, path, query_params)
  

end
list_courses_for_user(user_id,opts={}) click to toggle source

List courses for a user

# File lib/pandarus/v1_api.rb, line 6908
def list_courses_for_user(user_id,opts={})
  query_param_keys = [
    :include,
    :state,
    :enrollment_state

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/courses",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Course, path, query_params)
  

end
list_courses_with_their_latest_epub_export(opts={}) click to toggle source

List courses with their latest ePub export

# File lib/pandarus/v1_api.rb, line 26456
def list_courses_with_their_latest_epub_export(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/epub_exports",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CourseEpubExport, path, query_params)
  

end
list_custom_gradebook_columns(course_id,opts={}) click to toggle source

List custom gradebook columns

# File lib/pandarus/v1_api.rb, line 7831
def list_custom_gradebook_columns(course_id,opts={})
  query_param_keys = [
    :include_hidden

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/custom_gradebook_columns",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CustomColumn, path, query_params)
  

end
list_discussion_topics_courses(course_id,opts={}) click to toggle source

List discussion topics

# File lib/pandarus/v1_api.rb, line 8094
def list_discussion_topics_courses(course_id,opts={})
  query_param_keys = [
    :include,
    :order_by,
    :scope,
    :only_announcements,
    :search_term,
    :exclude_context_module_locked_topics

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, DiscussionTopic, path, query_params)
  

end
list_discussion_topics_groups(group_id,opts={}) click to toggle source

List discussion topics

# File lib/pandarus/v1_api.rb, line 8132
def list_discussion_topics_groups(group_id,opts={})
  query_param_keys = [
    :include,
    :order_by,
    :scope,
    :only_announcements,
    :search_term,
    :exclude_context_module_locked_topics

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, DiscussionTopic, path, query_params)
  

end
list_enabled_features_accounts(account_id,opts={}) click to toggle source

List enabled features

# File lib/pandarus/v1_api.rb, line 11452
def list_enabled_features_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/features/enabled",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_enabled_features_courses(course_id,opts={}) click to toggle source

List enabled features

# File lib/pandarus/v1_api.rb, line 11418
def list_enabled_features_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/features/enabled",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_enabled_features_users(user_id,opts={}) click to toggle source

List enabled features

# File lib/pandarus/v1_api.rb, line 11486
def list_enabled_features_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/features/enabled",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_enrollment_terms(account_id,opts={}) click to toggle source

List enrollment terms

# File lib/pandarus/v1_api.rb, line 10040
def list_enrollment_terms(account_id,opts={})
  query_param_keys = [
    :workflow_state,
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/terms",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, EnrollmentTerm, path, query_params)
  

end
list_enrollments_courses(course_id,opts={}) click to toggle source

List enrollments

# File lib/pandarus/v1_api.rb, line 10074
def list_enrollments_courses(course_id,opts={})
  query_param_keys = [
    :type,
    :role,
    :state,
    :include,
    :user_id,
    :grading_period_id,
    :sis_account_id,
    :sis_course_id,
    :sis_section_id,
    :sis_user_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/enrollments",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Enrollment, path, query_params)
  

end
list_enrollments_sections(section_id,opts={}) click to toggle source

List enrollments

# File lib/pandarus/v1_api.rb, line 10116
def list_enrollments_sections(section_id,opts={})
  query_param_keys = [
    :type,
    :role,
    :state,
    :include,
    :user_id,
    :grading_period_id,
    :sis_account_id,
    :sis_course_id,
    :sis_section_id,
    :sis_user_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/enrollments",
    :section_id => section_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Enrollment, path, query_params)
  

end
list_enrollments_users(user_id,opts={}) click to toggle source

List enrollments

# File lib/pandarus/v1_api.rb, line 10158
def list_enrollments_users(user_id,opts={})
  query_param_keys = [
    :type,
    :role,
    :state,
    :include,
    :grading_period_id,
    :sis_account_id,
    :sis_course_id,
    :sis_section_id,
    :sis_user_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/enrollments",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Enrollment, path, query_params)
  

end
list_entries_courses(course_id,topic_id,opts={}) click to toggle source

List entries

# File lib/pandarus/v1_api.rb, line 9156
def list_entries_courses(course_id,topic_id,opts={})
  query_param_keys = [
    :ids

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entry_list",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_entries_for_column(course_id,id,opts={}) click to toggle source

List entries for a column

# File lib/pandarus/v1_api.rb, line 8015
def list_entries_for_column(course_id,id,opts={})
  query_param_keys = [
    :include_hidden

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/custom_gradebook_columns/{id}/data",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ColumnDatum, path, query_params)
  

end
list_entries_groups(group_id,topic_id,opts={}) click to toggle source

List entries

# File lib/pandarus/v1_api.rb, line 9193
def list_entries_groups(group_id,topic_id,opts={})
  query_param_keys = [
    :ids

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entry_list",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_entry_replies_courses(course_id,topic_id,entry_id,opts={}) click to toggle source

List entry replies

# File lib/pandarus/v1_api.rb, line 9076
def list_entry_replies_courses(course_id,topic_id,entry_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries/{entry_id}/replies",
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_entry_replies_groups(group_id,topic_id,entry_id,opts={}) click to toggle source

List entry replies

# File lib/pandarus/v1_api.rb, line 9116
def list_entry_replies_groups(group_id,topic_id,entry_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries/{entry_id}/replies",
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_external_feeds_courses(course_id,opts={}) click to toggle source

List external feeds

# File lib/pandarus/v1_api.rb, line 1461
def list_external_feeds_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_feeds",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ExternalFeed, path, query_params)
  

end
list_external_feeds_groups(group_id,opts={}) click to toggle source

List external feeds

# File lib/pandarus/v1_api.rb, line 1494
def list_external_feeds_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/external_feeds",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ExternalFeed, path, query_params)
  

end
list_external_tools_accounts(account_id,opts={}) click to toggle source

List external tools

# File lib/pandarus/v1_api.rb, line 10483
def list_external_tools_accounts(account_id,opts={})
  query_param_keys = [
    :search_term,
    :selectable,
    :include_parents

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/external_tools",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_external_tools_courses(course_id,opts={}) click to toggle source

List external tools

# File lib/pandarus/v1_api.rb, line 10447
def list_external_tools_courses(course_id,opts={})
  query_param_keys = [
    :search_term,
    :selectable,
    :include_parents

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/external_tools",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_external_tools_groups(group_id,opts={}) click to toggle source

List external tools

# File lib/pandarus/v1_api.rb, line 10519
def list_external_tools_groups(group_id,opts={})
  query_param_keys = [
    :search_term,
    :selectable,
    :include_parents

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/external_tools",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_favorite_courses(opts={}) click to toggle source

List favorite courses

# File lib/pandarus/v1_api.rb, line 11053
def list_favorite_courses(opts={})
  query_param_keys = [
    :exclude_blueprint_courses

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/favorites/courses",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Course, path, query_params)
  

end
list_favorite_groups(opts={}) click to toggle source

List favorite groups

# File lib/pandarus/v1_api.rb, line 11085
def list_favorite_groups(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/favorites/groups",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Group, path, query_params)
  

end
list_features_accounts(account_id,opts={}) click to toggle source

List features

# File lib/pandarus/v1_api.rb, line 11352
def list_features_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/features",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Feature, path, query_params)
  

end
list_features_courses(course_id,opts={}) click to toggle source

List features

# File lib/pandarus/v1_api.rb, line 11319
def list_features_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/features",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Feature, path, query_params)
  

end
list_features_users(user_id,opts={}) click to toggle source

List features

# File lib/pandarus/v1_api.rb, line 11385
def list_features_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/features",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Feature, path, query_params)
  

end
list_files_courses(course_id,opts={}) click to toggle source

List files

# File lib/pandarus/v1_api.rb, line 11958
def list_files_courses(course_id,opts={})
  query_param_keys = [
    :content_types,
    :search_term,
    :include,
    :only,
    :sort,
    :order

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/files",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, File, path, query_params)
  

end
list_files_folders(id,opts={}) click to toggle source

List files

# File lib/pandarus/v1_api.rb, line 12072
def list_files_folders(id,opts={})
  query_param_keys = [
    :content_types,
    :search_term,
    :include,
    :only,
    :sort,
    :order

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/folders/{id}/files",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, File, path, query_params)
  

end
list_files_groups(group_id,opts={}) click to toggle source

List files

# File lib/pandarus/v1_api.rb, line 12034
def list_files_groups(group_id,opts={})
  query_param_keys = [
    :content_types,
    :search_term,
    :include,
    :only,
    :sort,
    :order

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/files",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, File, path, query_params)
  

end
list_files_users(user_id,opts={}) click to toggle source

List files

# File lib/pandarus/v1_api.rb, line 11996
def list_files_users(user_id,opts={})
  query_param_keys = [
    :content_types,
    :search_term,
    :include,
    :only,
    :sort,
    :order

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/files",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, File, path, query_params)
  

end
list_folders(id,opts={}) click to toggle source

List folders

# File lib/pandarus/v1_api.rb, line 12364
def list_folders(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/folders/{id}/folders",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
list_gradeable_students(course_id,assignment_id,opts={}) click to toggle source

List gradeable students

# File lib/pandarus/v1_api.rb, line 24463
def list_gradeable_students(course_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/gradeable_students",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_grading_periods_accounts(account_id,opts={}) click to toggle source

List grading periods

# File lib/pandarus/v1_api.rb, line 13823
def list_grading_periods_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/grading_periods",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_grading_periods_courses(course_id,opts={}) click to toggle source

List grading periods

# File lib/pandarus/v1_api.rb, line 13857
def list_grading_periods_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/grading_periods",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_grading_standards_available_in_context_accounts(account_id,opts={}) click to toggle source

List the grading standards available in a context.

# File lib/pandarus/v1_api.rb, line 14165
def list_grading_standards_available_in_context_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/grading_standards",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GradingStandard, path, query_params)
  

end
list_grading_standards_available_in_context_courses(course_id,opts={}) click to toggle source

List the grading standards available in a context.

# File lib/pandarus/v1_api.rb, line 14132
def list_grading_standards_available_in_context_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/grading_standards",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GradingStandard, path, query_params)
  

end
list_group_categories_for_context_accounts(account_id,opts={}) click to toggle source

List group categories for a context

# File lib/pandarus/v1_api.rb, line 14272
def list_group_categories_for_context_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/group_categories",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GroupCategory, path, query_params)
  

end
list_group_categories_for_context_courses(course_id,opts={}) click to toggle source

List group categories for a context

# File lib/pandarus/v1_api.rb, line 14305
def list_group_categories_for_context_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/group_categories",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GroupCategory, path, query_params)
  

end
list_group_memberships(group_id,opts={}) click to toggle source

List group memberships

# File lib/pandarus/v1_api.rb, line 15127
def list_group_memberships(group_id,opts={})
  query_param_keys = [
    :filter_states

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/memberships",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GroupMembership, path, query_params)
  

end
list_group_s_users(group_id,opts={}) click to toggle source

List group's users

# File lib/pandarus/v1_api.rb, line 14956
def list_group_s_users(group_id,opts={})
  query_param_keys = [
    :search_term,
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/users",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_groups_available_in_context_accounts(account_id,opts={}) click to toggle source

List the groups available in a context.

# File lib/pandarus/v1_api.rb, line 14665
def list_groups_available_in_context_accounts(account_id,opts={})
  query_param_keys = [
    :only_own_groups,
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/groups",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Group, path, query_params)
  

end
list_groups_available_in_context_courses(course_id,opts={}) click to toggle source

List the groups available in a context.

# File lib/pandarus/v1_api.rb, line 14699
def list_groups_available_in_context_courses(course_id,opts={})
  query_param_keys = [
    :only_own_groups,
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/groups",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Group, path, query_params)
  

end
list_groups_in_group_category(group_category_id,opts={}) click to toggle source

List groups in group category

# File lib/pandarus/v1_api.rb, line 14530
def list_groups_in_group_category(group_category_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_category_id is required" if group_category_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_category_id => group_category_id

  )

  # resource path
  path = path_replace("/v1/group_categories/{group_category_id}/groups",
    :group_category_id => group_category_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Group, path, query_params)
  

end
list_licenses_courses(course_id,opts={}) click to toggle source

List licenses

# File lib/pandarus/v1_api.rb, line 13442
def list_licenses_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_licenses",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, License, path, query_params)
  

end
list_licenses_groups(group_id,opts={}) click to toggle source

List licenses

# File lib/pandarus/v1_api.rb, line 13475
def list_licenses_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_licenses",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, License, path, query_params)
  

end
list_licenses_users(user_id,opts={}) click to toggle source

List licenses

# File lib/pandarus/v1_api.rb, line 13508
def list_licenses_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_licenses",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, License, path, query_params)
  

end
list_linked_outcomes_accounts(account_id,id,opts={}) click to toggle source

List linked outcomes

# File lib/pandarus/v1_api.rb, line 17772
def list_linked_outcomes_accounts(account_id,id,opts={})
  query_param_keys = [
    :outcome_style

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/outcome_groups/{id}/outcomes",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, OutcomeLink, path, query_params)
  

end
list_linked_outcomes_courses(course_id,id,opts={}) click to toggle source

List linked outcomes

# File lib/pandarus/v1_api.rb, line 17808
def list_linked_outcomes_courses(course_id,id,opts={})
  query_param_keys = [
    :outcome_style

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_groups/{id}/outcomes",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, OutcomeLink, path, query_params)
  

end
list_linked_outcomes_global(id,opts={}) click to toggle source

List linked outcomes

# File lib/pandarus/v1_api.rb, line 17739
def list_linked_outcomes_global(id,opts={})
  query_param_keys = [
    :outcome_style

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/global/outcome_groups/{id}/outcomes",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, OutcomeLink, path, query_params)
  

end
list_live_assessment_results(course_id,assessment_id,opts={}) click to toggle source

List live assessment results

# File lib/pandarus/v1_api.rb, line 15642
def list_live_assessment_results(course_id,assessment_id,opts={})
  query_param_keys = [
    :user_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assessment_id is required" if assessment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assessment_id => assessment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/live_assessments/{assessment_id}/results",
    :course_id => course_id,
    :assessment_id => assessment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_live_assessments(course_id,opts={}) click to toggle source

List live assessments

# File lib/pandarus/v1_api.rb, line 15713
def list_live_assessments(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/live_assessments",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_members_of_collaboration(id,opts={}) click to toggle source

List members of a collaboration.

# File lib/pandarus/v1_api.rb, line 4389
def list_members_of_collaboration(id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/collaborations/{id}/members",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Collaborator, path, query_params)
  

end
list_migration_issues_accounts(account_id,content_migration_id,opts={}) click to toggle source

List migration issues

# File lib/pandarus/v1_api.rb, line 5065
def list_migration_issues_accounts(account_id,content_migration_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :content_migration_id => content_migration_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/content_migrations/{content_migration_id}/migration_issues",
    :account_id => account_id,
    :content_migration_id => content_migration_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, MigrationIssue, path, query_params)
  

end
list_migration_issues_courses(course_id,content_migration_id,opts={}) click to toggle source

List migration issues

# File lib/pandarus/v1_api.rb, line 5101
def list_migration_issues_courses(course_id,content_migration_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :content_migration_id => content_migration_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_migrations/{content_migration_id}/migration_issues",
    :course_id => course_id,
    :content_migration_id => content_migration_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, MigrationIssue, path, query_params)
  

end
list_migration_issues_groups(group_id,content_migration_id,opts={}) click to toggle source

List migration issues

# File lib/pandarus/v1_api.rb, line 5137
def list_migration_issues_groups(group_id,content_migration_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :content_migration_id => content_migration_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_migrations/{content_migration_id}/migration_issues",
    :group_id => group_id,
    :content_migration_id => content_migration_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, MigrationIssue, path, query_params)
  

end
list_migration_issues_users(user_id,content_migration_id,opts={}) click to toggle source

List migration issues

# File lib/pandarus/v1_api.rb, line 5173
def list_migration_issues_users(user_id,content_migration_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :content_migration_id => content_migration_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_migrations/{content_migration_id}/migration_issues",
    :user_id => user_id,
    :content_migration_id => content_migration_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, MigrationIssue, path, query_params)
  

end
list_migration_systems_accounts(account_id,opts={}) click to toggle source

List Migration Systems

# File lib/pandarus/v1_api.rb, line 6177
def list_migration_systems_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/content_migrations/migrators",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Migrator, path, query_params)
  

end
list_migration_systems_courses(course_id,opts={}) click to toggle source

List Migration Systems

# File lib/pandarus/v1_api.rb, line 6210
def list_migration_systems_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_migrations/migrators",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Migrator, path, query_params)
  

end
list_migration_systems_groups(group_id,opts={}) click to toggle source

List Migration Systems

# File lib/pandarus/v1_api.rb, line 6243
def list_migration_systems_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_migrations/migrators",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Migrator, path, query_params)
  

end
list_migration_systems_users(user_id,opts={}) click to toggle source

List Migration Systems

# File lib/pandarus/v1_api.rb, line 6276
def list_migration_systems_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_migrations/migrators",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Migrator, path, query_params)
  

end
list_missing_submissions(user_id,opts={}) click to toggle source

List Missing Submissions

# File lib/pandarus/v1_api.rb, line 25434
def list_missing_submissions(user_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/missing_submissions",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Assignment, path, query_params)
  

end
list_module_items(course_id,module_id,opts={}) click to toggle source

List module items

# File lib/pandarus/v1_api.rb, line 16397
def list_module_items(course_id,module_id,opts={})
  query_param_keys = [
    :include,
    :search_term,
    :student_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module_id is required" if module_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module_id => module_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{module_id}/items",
    :course_id => course_id,
    :module_id => module_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, ModuleItem, path, query_params)
  

end
list_modules(course_id,opts={}) click to toggle source

List modules

# File lib/pandarus/v1_api.rb, line 16164
def list_modules(course_id,opts={})
  query_param_keys = [
    :include,
    :search_term,
    :student_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Module, path, query_params)
  

end
list_multiple_assignments_gradeable_students(course_id,opts={}) click to toggle source

List multiple assignments gradeable students

# File lib/pandarus/v1_api.rb, line 24500
def list_multiple_assignments_gradeable_students(course_id,opts={})
  query_param_keys = [
    :assignment_ids

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/gradeable_students",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_observees(user_id,opts={}) click to toggle source

List observees

# File lib/pandarus/v1_api.rb, line 25053
def list_observees(user_id,opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/observees",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_of_commmessages_for_user(user_id,opts={}) click to toggle source

List of CommMessages for a user

# File lib/pandarus/v1_api.rb, line 4488
def list_of_commmessages_for_user(user_id,opts={})
  query_param_keys = [
    :user_id,
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/comm_messages",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CommMessage, path, query_params)
  

end
list_of_preference_categories(user_id,communication_channel_id,opts={}) click to toggle source

List of preference categories

# File lib/pandarus/v1_api.rb, line 16848
def list_of_preference_categories(user_id,communication_channel_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "communication_channel_id is required" if communication_channel_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :communication_channel_id => communication_channel_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels/{communication_channel_id}/notification_preference_categories",
    :user_id => user_id,
    :communication_channel_id => communication_channel_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_opened_poll_sessions(opts={}) click to toggle source

List opened poll sessions

# File lib/pandarus/v1_api.rb, line 20585
def list_opened_poll_sessions(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/poll_sessions/opened",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_pages_courses(course_id,opts={}) click to toggle source

List pages

# File lib/pandarus/v1_api.rb, line 18921
def list_pages_courses(course_id,opts={})
  query_param_keys = [
    :sort,
    :order,
    :search_term,
    :published

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Page, path, query_params)
  

end
list_pages_groups(group_id,opts={}) click to toggle source

List pages

# File lib/pandarus/v1_api.rb, line 18957
def list_pages_groups(group_id,opts={})
  query_param_keys = [
    :sort,
    :order,
    :search_term,
    :published

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Page, path, query_params)
  

end
list_planner_items(opts={}) click to toggle source

List planner items

# File lib/pandarus/v1_api.rb, line 20116
def list_planner_items(opts={})
  query_param_keys = [
    :start_date,
    :end_date,
    :filter

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/planner/items",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_planner_notes(opts={}) click to toggle source

List planner notes

# File lib/pandarus/v1_api.rb, line 19937
def list_planner_notes(opts={})
  query_param_keys = [
    :start_date,
    :end_date,
    :context_codes

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/planner_notes",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PlannerNote, path, query_params)
  

end
list_planner_overrides(opts={}) click to toggle source

List planner overrides

# File lib/pandarus/v1_api.rb, line 20151
def list_planner_overrides(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/planner/overrides",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PlannerOverride, path, query_params)
  

end
list_poll_choices_in_poll(poll_id,opts={}) click to toggle source

List poll choices in a poll

# File lib/pandarus/v1_api.rb, line 20651
def list_poll_choices_in_poll(poll_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_choices",
    :poll_id => poll_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_poll_sessions_for_poll(poll_id,opts={}) click to toggle source

List poll sessions for a poll

# File lib/pandarus/v1_api.rb, line 20324
def list_poll_sessions_for_poll(poll_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions",
    :poll_id => poll_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_polls(opts={}) click to toggle source

List polls

# File lib/pandarus/v1_api.rb, line 20920
def list_polls(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/polls",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_potential_members_courses(course_id,opts={}) click to toggle source

List potential members

# File lib/pandarus/v1_api.rb, line 4422
def list_potential_members_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/potential_collaborators",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_potential_members_groups(group_id,opts={}) click to toggle source

List potential members

# File lib/pandarus/v1_api.rb, line 4455
def list_potential_members_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/potential_collaborators",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_preferences_communication_channel_id(user_id,communication_channel_id,opts={}) click to toggle source

List preferences

# File lib/pandarus/v1_api.rb, line 16773
def list_preferences_communication_channel_id(user_id,communication_channel_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "communication_channel_id is required" if communication_channel_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :communication_channel_id => communication_channel_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels/{communication_channel_id}/notification_preferences",
    :user_id => user_id,
    :communication_channel_id => communication_channel_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, NotificationPreference, path, query_params)
  

end
list_preferences_type(user_id,type,address,opts={}) click to toggle source

List preferences

# File lib/pandarus/v1_api.rb, line 16809
def list_preferences_type(user_id,type,address,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "type is required" if type.nil?
  raise "address is required" if address.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :type => type,
    :address => address

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels/{type}/{address}/notification_preferences",
    :user_id => user_id,
    :type => type,
    :address => address)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, NotificationPreference, path, query_params)
  

end
list_questions_in_quiz_or_submission(course_id,quiz_id,opts={}) click to toggle source

List questions in a quiz or a submission

# File lib/pandarus/v1_api.rb, line 21453
def list_questions_in_quiz_or_submission(course_id,quiz_id,opts={})
  query_param_keys = [
    :quiz_submission_id,
    :quiz_submission_attempt

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/questions",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, QuizQuestion, path, query_params)
  

end
list_quizzes_in_course(course_id,opts={}) click to toggle source

List quizzes in a course

# File lib/pandarus/v1_api.rb, line 22472
def list_quizzes_in_course(course_id,opts={})
  query_param_keys = [
    :search_term

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Quiz, path, query_params)
  

end
list_recently_logged_in_students(course_id,opts={}) click to toggle source

List recently logged in students

# File lib/pandarus/v1_api.rb, line 7152
def list_recently_logged_in_students(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/recent_students",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_revisions_courses(course_id,url,opts={}) click to toggle source

List revisions

# File lib/pandarus/v1_api.rb, line 19311
def list_revisions_courses(course_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages/{url}/revisions",
    :course_id => course_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PageRevision, path, query_params)
  

end
list_revisions_groups(group_id,url,opts={}) click to toggle source

List revisions

# File lib/pandarus/v1_api.rb, line 19347
def list_revisions_groups(group_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages/{url}/revisions",
    :group_id => group_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PageRevision, path, query_params)
  

end
list_roles(account_id,opts={}) click to toggle source

List roles

# File lib/pandarus/v1_api.rb, line 22757
def list_roles(account_id,opts={})
  query_param_keys = [
    :state,
    :show_inherited

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/roles",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Role, path, query_params)
  

end
list_rubrics_accounts(account_id,opts={}) click to toggle source

List rubrics

# File lib/pandarus/v1_api.rb, line 22998
def list_rubrics_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/rubrics",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_rubrics_courses(course_id,opts={}) click to toggle source

List rubrics

# File lib/pandarus/v1_api.rb, line 23032
def list_rubrics_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/rubrics",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_student_group_participants(id,opts={}) click to toggle source

List student group participants

# File lib/pandarus/v1_api.rb, line 1949
def list_student_group_participants(id,opts={})
  query_param_keys = [
    :registration_status

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/appointment_groups/{id}/groups",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_students(course_id,opts={}) click to toggle source

List students

# File lib/pandarus/v1_api.rb, line 7039
def list_students(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/students",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_students_selected_for_moderation(course_id,assignment_id,opts={}) click to toggle source

List students selected for moderation

# File lib/pandarus/v1_api.rb, line 15937
def list_students_selected_for_moderation(course_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/moderated_students",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_subgroups_accounts(account_id,id,opts={}) click to toggle source

List subgroups

# File lib/pandarus/v1_api.rb, line 18276
def list_subgroups_accounts(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/outcome_groups/{id}/subgroups",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, OutcomeGroup, path, query_params)
  

end
list_subgroups_courses(course_id,id,opts={}) click to toggle source

List subgroups

# File lib/pandarus/v1_api.rb, line 18312
def list_subgroups_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_groups/{id}/subgroups",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, OutcomeGroup, path, query_params)
  

end
list_subgroups_global(id,opts={}) click to toggle source

List subgroups

# File lib/pandarus/v1_api.rb, line 18243
def list_subgroups_global(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/global/outcome_groups/{id}/subgroups",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, OutcomeGroup, path, query_params)
  

end
list_submissions_for_multiple_assignments_courses(course_id,opts={}) click to toggle source

List submissions for multiple assignments

# File lib/pandarus/v1_api.rb, line 24115
def list_submissions_for_multiple_assignments_courses(course_id,opts={})
  query_param_keys = [
    :student_ids,
    :assignment_ids,
    :grouped,
    :post_to_sis,
    :grading_period_id,
    :workflow_state,
    :enrollment_state,
    :order,
    :order_direction,
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/students/submissions",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_submissions_for_multiple_assignments_sections(section_id,opts={}) click to toggle source

List submissions for multiple assignments

# File lib/pandarus/v1_api.rb, line 24158
def list_submissions_for_multiple_assignments_sections(section_id,opts={})
  query_param_keys = [
    :student_ids,
    :assignment_ids,
    :grouped,
    :post_to_sis,
    :grading_period_id,
    :workflow_state,
    :enrollment_state,
    :order,
    :order_direction,
    :include

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/students/submissions",
    :section_id => section_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_todo_items(opts={}) click to toggle source

List the TODO items

# File lib/pandarus/v1_api.rb, line 25368
def list_todo_items(opts={})
  query_param_keys = [
    :include

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/todo",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_topic_entries_courses(course_id,topic_id,opts={}) click to toggle source

List topic entries

# File lib/pandarus/v1_api.rb, line 8918
def list_topic_entries_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_topic_entries_groups(group_id,topic_id,opts={}) click to toggle source

List topic entries

# File lib/pandarus/v1_api.rb, line 8955
def list_topic_entries_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_uncollated_submission_versions(course_id,opts={}) click to toggle source

List uncollated submission versions

# File lib/pandarus/v1_api.rb, line 13788
def list_uncollated_submission_versions(course_id,opts={})
  query_param_keys = [
    :assignment_id,
    :user_id,
    :ascending

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/gradebook_history/feed",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, SubmissionVersion, path, query_params)
  

end
list_upcoming_assignments_calendar_events(opts={}) click to toggle source

List upcoming assignments, calendar events

# File lib/pandarus/v1_api.rb, line 25401
def list_upcoming_assignments_calendar_events(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/upcoming_events",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_user_communication_channels(user_id,opts={}) click to toggle source

List user communication channels

# File lib/pandarus/v1_api.rb, line 4523
def list_user_communication_channels(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/communication_channels",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CommunicationChannel, path, query_params)
  

end
list_user_logins_accounts(account_id,opts={}) click to toggle source

List user logins

# File lib/pandarus/v1_api.rb, line 15747
def list_user_logins_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/logins",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_user_logins_users(user_id,opts={}) click to toggle source

List user logins

# File lib/pandarus/v1_api.rb, line 15781
def list_user_logins_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/logins",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_user_page_views(user_id,opts={}) click to toggle source

List user page views

# File lib/pandarus/v1_api.rb, line 26140
def list_user_page_views(user_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/page_views",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, PageView, path, query_params)
  

end
list_user_participants(id,opts={}) click to toggle source

List user participants

# File lib/pandarus/v1_api.rb, line 1915
def list_user_participants(id,opts={})
  query_param_keys = [
    :registration_status

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/appointment_groups/{id}/users",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
list_users_in_account(account_id,opts={}) click to toggle source

List users in account

# File lib/pandarus/v1_api.rb, line 25234
def list_users_in_account(account_id,opts={})
  query_param_keys = [
    :search_term,
    :sort,
    :order

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/users",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_users_in_course_search_users(course_id,opts={}) click to toggle source

List users in course

# File lib/pandarus/v1_api.rb, line 7112
def list_users_in_course_search_users(course_id,opts={})
  query_param_keys = [
    :search_term,
    :enrollment_type,
    :enrollment_role,
    :enrollment_role_id,
    :include,
    :user_id,
    :user_ids,
    :enrollment_state

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/search_users",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_users_in_course_users(course_id,opts={}) click to toggle source

List users in course

# File lib/pandarus/v1_api.rb, line 7072
def list_users_in_course_users(course_id,opts={})
  query_param_keys = [
    :search_term,
    :enrollment_type,
    :enrollment_role,
    :enrollment_role_id,
    :include,
    :user_id,
    :user_ids,
    :enrollment_state

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/users",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_users_in_group_category(group_category_id,opts={}) click to toggle source

List users in group category

# File lib/pandarus/v1_api.rb, line 14563
def list_users_in_group_category(group_category_id,opts={})
  query_param_keys = [
    :search_term,
    :unassigned

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_category_id is required" if group_category_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_category_id => group_category_id

  )

  # resource path
  path = path_replace("/v1/group_categories/{group_category_id}/users",
    :group_category_id => group_category_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
list_your_courses(opts={}) click to toggle source

List your courses

# File lib/pandarus/v1_api.rb, line 6870
def list_your_courses(opts={})
  query_param_keys = [
    :enrollment_type,
    :enrollment_role,
    :enrollment_role_id,
    :enrollment_state,
    :exclude_blueprint_courses,
    :include,
    :state

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/courses",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Course, path, query_params)
  

end
list_your_groups(opts={}) click to toggle source

List your groups

# File lib/pandarus/v1_api.rb, line 14632
def list_your_groups(opts={})
  query_param_keys = [
    :context_type,
    :include

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/groups",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Group, path, query_params)
  

end
lists_submissions(course_id,date,grader_id,assignment_id,opts={}) click to toggle source

Lists submissions

# File lib/pandarus/v1_api.rb, line 13746
def lists_submissions(course_id,date,grader_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "date is required" if date.nil?
  raise "grader_id is required" if grader_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :date => date,
    :grader_id => grader_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/gradebook_history/{date}/graders/{grader_id}/assignments/{assignment_id}/submissions",
    :course_id => course_id,
    :date => date,
    :grader_id => grader_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, SubmissionHistory, path, query_params)
  

end
load_custom_data(user_id,ns,opts={}) click to toggle source

Load custom data

# File lib/pandarus/v1_api.rb, line 26214
def load_custom_data(user_id,ns,opts={})
  query_param_keys = [
    :ns

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "ns is required" if ns.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :ns => ns

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/custom_data",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
make_account_admin(account_id,user_id,opts={}) click to toggle source

Make an account admin

# File lib/pandarus/v1_api.rb, line 821
def make_account_admin(account_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user_id,
    :role,
    :role_id,
    :send_confirmation,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/admins",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Admin.new(response)
  

end
mark_all_as_read(opts={}) click to toggle source

Mark all as read

# File lib/pandarus/v1_api.rb, line 6506
def mark_all_as_read(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/conversations/mark_all_as_read",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
mark_all_entries_as_read_courses(course_id,topic_id,opts={}) click to toggle source

Mark all entries as read

# File lib/pandarus/v1_api.rb, line 9378
def mark_all_entries_as_read_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :forced_read_state,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/read_all",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_all_entries_as_read_groups(group_id,topic_id,opts={}) click to toggle source

Mark all entries as read

# File lib/pandarus/v1_api.rb, line 9416
def mark_all_entries_as_read_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :forced_read_state,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/read_all",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_all_entries_as_unread_courses(course_id,topic_id,opts={}) click to toggle source

Mark all entries as unread

# File lib/pandarus/v1_api.rb, line 9454
def mark_all_entries_as_unread_courses(course_id,topic_id,opts={})
  query_param_keys = [
    :forced_read_state

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/read_all",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
mark_all_entries_as_unread_groups(group_id,topic_id,opts={}) click to toggle source

Mark all entries as unread

# File lib/pandarus/v1_api.rb, line 9491
def mark_all_entries_as_unread_groups(group_id,topic_id,opts={})
  query_param_keys = [
    :forced_read_state

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/read_all",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
mark_entry_as_read_courses(course_id,topic_id,entry_id,opts={}) click to toggle source

Mark entry as read

# File lib/pandarus/v1_api.rb, line 9528
def mark_entry_as_read_courses(course_id,topic_id,entry_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :forced_read_state,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries/{entry_id}/read",
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_entry_as_read_groups(group_id,topic_id,entry_id,opts={}) click to toggle source

Mark entry as read

# File lib/pandarus/v1_api.rb, line 9569
def mark_entry_as_read_groups(group_id,topic_id,entry_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :forced_read_state,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries/{entry_id}/read",
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_entry_as_unread_courses(course_id,topic_id,entry_id,opts={}) click to toggle source

Mark entry as unread

# File lib/pandarus/v1_api.rb, line 9610
def mark_entry_as_unread_courses(course_id,topic_id,entry_id,opts={})
  query_param_keys = [
    :forced_read_state

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries/{entry_id}/read",
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
mark_entry_as_unread_groups(group_id,topic_id,entry_id,opts={}) click to toggle source

Mark entry as unread

# File lib/pandarus/v1_api.rb, line 9650
def mark_entry_as_unread_groups(group_id,topic_id,entry_id,opts={})
  query_param_keys = [
    :forced_read_state

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries/{entry_id}/read",
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
mark_module_item_as_done_not_done(course_id,module_id,id,opts={}) click to toggle source

Mark module item as done/not done

# File lib/pandarus/v1_api.rb, line 16658
def mark_module_item_as_done_not_done(course_id,module_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module_id is required" if module_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module_id => module_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{module_id}/items/{id}/done",
    :course_id => course_id,
    :module_id => module_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_module_item_read(course_id,module_id,id,opts={}) click to toggle source

Mark module item read

# File lib/pandarus/v1_api.rb, line 16733
def mark_module_item_read(course_id,module_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module_id is required" if module_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module_id => module_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{module_id}/items/{id}/mark_read",
    :course_id => course_id,
    :module_id => module_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
mark_submission_as_read_courses(course_id,assignment_id,user_id,opts={}) click to toggle source

Mark submission as read

# File lib/pandarus/v1_api.rb, line 24712
def mark_submission_as_read_courses(course_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{user_id}/read",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_submission_as_read_sections(section_id,assignment_id,user_id,opts={}) click to toggle source

Mark submission as read

# File lib/pandarus/v1_api.rb, line 24752
def mark_submission_as_read_sections(section_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/{user_id}/read",
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_submission_as_unread_courses(course_id,assignment_id,user_id,opts={}) click to toggle source

Mark submission as unread

# File lib/pandarus/v1_api.rb, line 24792
def mark_submission_as_unread_courses(course_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{user_id}/read",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
mark_submission_as_unread_sections(section_id,assignment_id,user_id,opts={}) click to toggle source

Mark submission as unread

# File lib/pandarus/v1_api.rb, line 24832
def mark_submission_as_unread_sections(section_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/{user_id}/read",
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
mark_topic_as_read_courses(course_id,topic_id,opts={}) click to toggle source

Mark topic as read

# File lib/pandarus/v1_api.rb, line 9230
def mark_topic_as_read_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/read",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_topic_as_read_groups(group_id,topic_id,opts={}) click to toggle source

Mark topic as read

# File lib/pandarus/v1_api.rb, line 9267
def mark_topic_as_read_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/read",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
mark_topic_as_unread_courses(course_id,topic_id,opts={}) click to toggle source

Mark topic as unread

# File lib/pandarus/v1_api.rb, line 9304
def mark_topic_as_unread_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/read",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
mark_topic_as_unread_groups(group_id,topic_id,opts={}) click to toggle source

Mark topic as unread

# File lib/pandarus/v1_api.rb, line 9341
def mark_topic_as_unread_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/read",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
merge_user_into_another_user_accounts(id,destination_account_id,destination_user_id,opts={}) click to toggle source

Merge user into another user

# File lib/pandarus/v1_api.rb, line 26000
def merge_user_into_another_user_accounts(id,destination_account_id,destination_user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "destination_account_id is required" if destination_account_id.nil?
  raise "destination_user_id is required" if destination_user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :destination_account_id => destination_account_id,
    :destination_user_id => destination_user_id

  )

  # resource path
  path = path_replace("/v1/users/{id}/merge_into/accounts/{destination_account_id}/users/{destination_user_id}",
    :id => id,
    :destination_account_id => destination_account_id,
    :destination_user_id => destination_user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  User.new(response)
  

end
merge_user_into_another_user_destination_user_id(id,destination_user_id,opts={}) click to toggle source

Merge user into another user

# File lib/pandarus/v1_api.rb, line 25963
def merge_user_into_another_user_destination_user_id(id,destination_user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "destination_user_id is required" if destination_user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :destination_user_id => destination_user_id

  )

  # resource path
  path = path_replace("/v1/users/{id}/merge_into/{destination_user_id}",
    :id => id,
    :destination_user_id => destination_user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  User.new(response)
  

end
open_poll_session(poll_id,id,opts={}) click to toggle source

Open a poll session

# File lib/pandarus/v1_api.rb, line 20511
def open_poll_session(poll_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions/{id}/open",
    :poll_id => poll_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
patch_late_policy(id,opts={}) click to toggle source

Patch a late policy

# File lib/pandarus/v1_api.rb, line 15564
def patch_late_policy(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :late_policy__missing_submission_deduction_enabled__,
    :late_policy__missing_submission_deduction__,
    :late_policy__late_submission_deduction_enabled__,
    :late_policy__late_submission_deduction__,
    :late_policy__late_submission_interval__,
    :late_policy__late_submission_minimum_percent_enabled__,
    :late_policy__late_submission_minimum_percent__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{id}/late_policy",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:patch, path, query_params, form_params, headers)
  response
  

end
permissions(course_id,opts={}) click to toggle source

Permissions

# File lib/pandarus/v1_api.rb, line 7723
def permissions(course_id,opts={})
  query_param_keys = [
    :permissions

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/permissions",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
post_entry_courses(course_id,topic_id,opts={}) click to toggle source

Post an entry

# File lib/pandarus/v1_api.rb, line 8840
def post_entry_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :message,
    :attachment,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
post_entry_groups(group_id,topic_id,opts={}) click to toggle source

Post an entry

# File lib/pandarus/v1_api.rb, line 8879
def post_entry_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :message,
    :attachment,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
post_reply_courses(course_id,topic_id,entry_id,opts={}) click to toggle source

Post a reply

# File lib/pandarus/v1_api.rb, line 8992
def post_reply_courses(course_id,topic_id,entry_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :message,
    :attachment,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries/{entry_id}/replies",
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
post_reply_groups(group_id,topic_id,entry_id,opts={}) click to toggle source

Post a reply

# File lib/pandarus/v1_api.rb, line 9034
def post_reply_groups(group_id,topic_id,entry_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :message,
    :attachment,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries/{entry_id}/replies",
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
preview_processed_html(course_id,opts={}) click to toggle source

Preview processed html

# File lib/pandarus/v1_api.rb, line 7222
def preview_processed_html(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :html,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/preview_html",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
preview_processed_html_V1_0(group_id,opts={}) click to toggle source

Preview processed html

# File lib/pandarus/v1_api.rb, line 15024
def preview_processed_html_V1_0(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :html,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/preview_html",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
publish_provisional_grades_for_assignment(course_id,assignment_id,opts={}) click to toggle source

Publish provisional grades for an assignment

# File lib/pandarus/v1_api.rb, line 16127
def publish_provisional_grades_for_assignment(course_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/provisional_grades/publish",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
query_by_account(account_id,opts={}) click to toggle source

Query by account.

# File lib/pandarus/v1_api.rb, line 3158
def query_by_account(account_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/audit/authentication/accounts/{account_id}",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
query_by_assignment(assignment_id,opts={}) click to toggle source

Query by assignment.

# File lib/pandarus/v1_api.rb, line 13541
def query_by_assignment(assignment_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/audit/grade_change/assignments/{assignment_id}",
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GradeChangeEvent, path, query_params)
  

end
query_by_course(course_id,opts={}) click to toggle source

Query by course.

# File lib/pandarus/v1_api.rb, line 6794
def query_by_course(course_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/audit/course/courses/{course_id}",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, CourseEvent, path, query_params)
  

end
query_by_course_V1_0(course_id,opts={}) click to toggle source

Query by course.

# File lib/pandarus/v1_api.rb, line 13575
def query_by_course_V1_0(course_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/audit/grade_change/courses/{course_id}",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GradeChangeEvent, path, query_params)
  

end
query_by_grader(grader_id,opts={}) click to toggle source

Query by grader.

# File lib/pandarus/v1_api.rb, line 13643
def query_by_grader(grader_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "grader_id is required" if grader_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :grader_id => grader_id

  )

  # resource path
  path = path_replace("/v1/audit/grade_change/graders/{grader_id}",
    :grader_id => grader_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GradeChangeEvent, path, query_params)
  

end
query_by_login(login_id,opts={}) click to toggle source

Query by login.

# File lib/pandarus/v1_api.rb, line 3123
def query_by_login(login_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "login_id is required" if login_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :login_id => login_id

  )

  # resource path
  path = path_replace("/v1/audit/authentication/logins/{login_id}",
    :login_id => login_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
query_by_student(student_id,opts={}) click to toggle source

Query by student.

# File lib/pandarus/v1_api.rb, line 13609
def query_by_student(student_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "student_id is required" if student_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :student_id => student_id

  )

  # resource path
  path = path_replace("/v1/audit/grade_change/students/{student_id}",
    :student_id => student_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, GradeChangeEvent, path, query_params)
  

end
query_by_user(user_id,opts={}) click to toggle source

Query by user.

# File lib/pandarus/v1_api.rb, line 3193
def query_by_user(user_id,opts={})
  query_param_keys = [
    :start_time,
    :end_time

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/audit/authentication/users/{user_id}",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
query_progress(id,opts={}) click to toggle source

Query progress

# File lib/pandarus/v1_api.rb, line 21095
def query_progress(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/progress/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Progress.new(response)
  

end
rate_entry_courses(course_id,topic_id,entry_id,opts={}) click to toggle source

Rate entry

# File lib/pandarus/v1_api.rb, line 9690
def rate_entry_courses(course_id,topic_id,entry_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :rating,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries/{entry_id}/rating",
    :course_id => course_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
rate_entry_groups(group_id,topic_id,entry_id,opts={}) click to toggle source

Rate entry

# File lib/pandarus/v1_api.rb, line 9731
def rate_entry_groups(group_id,topic_id,entry_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :rating,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "entry_id is required" if entry_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries/{entry_id}/rating",
    :group_id => group_id,
    :topic_id => topic_id,
    :entry_id => entry_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
re_activate_enrollment(course_id,id,opts={}) click to toggle source

Re-activate an enrollment

# File lib/pandarus/v1_api.rb, line 10371
def re_activate_enrollment(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/enrollments/{id}/reactivate",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Enrollment.new(response)
  

end
re_lock_module_progressions(course_id,id,opts={}) click to toggle source

Re-lock module progressions

# File lib/pandarus/v1_api.rb, line 16360
def re_lock_module_progressions(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{id}/relock",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Module.new(response)
  

end
redirect_to_assignment_override_for_group(group_id,assignment_id,opts={}) click to toggle source

Redirect to the assignment override for a group

# File lib/pandarus/v1_api.rb, line 2564
def redirect_to_assignment_override_for_group(group_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/assignments/{assignment_id}/override",
    :group_id => group_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
redirect_to_assignment_override_for_section(course_section_id,assignment_id,opts={}) click to toggle source

Redirect to the assignment override for a section

# File lib/pandarus/v1_api.rb, line 2601
def redirect_to_assignment_override_for_section(course_section_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_section_id is required" if course_section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_section_id => course_section_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/sections/{course_section_id}/assignments/{assignment_id}/override",
    :course_section_id => course_section_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
redirect_to_root_outcome_group_for_context_accounts(account_id,opts={}) click to toggle source

Redirect to root outcome group for context

# File lib/pandarus/v1_api.rb, line 17201
def redirect_to_root_outcome_group_for_context_accounts(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/root_outcome_group",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
redirect_to_root_outcome_group_for_context_courses(course_id,opts={}) click to toggle source

Redirect to root outcome group for context

# File lib/pandarus/v1_api.rb, line 17235
def redirect_to_root_outcome_group_for_context_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/root_outcome_group",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
redirect_to_root_outcome_group_for_context_global(opts={}) click to toggle source

Redirect to root outcome group for context

# File lib/pandarus/v1_api.rb, line 17168
def redirect_to_root_outcome_group_for_context_global(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/global/root_outcome_group",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
refresh_jwt(jwt,opts={}) click to toggle source

Refresh JWT

# File lib/pandarus/v1_api.rb, line 15454
def refresh_jwt(jwt,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :jwt,
    

  ]

  # verify existence of params
  raise "jwt is required" if jwt.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :jwt => jwt

  )

  # resource path
  path = path_replace("/v1/jwts/refresh",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  JWT.new(response)
  

end
remove_account_admin(account_id,user_id,opts={}) click to toggle source

Remove account admin

# File lib/pandarus/v1_api.rb, line 861
def remove_account_admin(account_id,user_id,opts={})
  query_param_keys = [
    :role,
    :role_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/admins/{user_id}",
    :account_id => account_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Admin.new(response)
  

end
remove_course_from_favorites(id,opts={}) click to toggle source

Remove course from favorites

# File lib/pandarus/v1_api.rb, line 11185
def remove_course_from_favorites(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/self/favorites/courses/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Favorite.new(response)
  

end
remove_course_nickname(course_id,opts={}) click to toggle source

Remove course nickname

# File lib/pandarus/v1_api.rb, line 26389
def remove_course_nickname(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/users/self/course_nicknames/{course_id}",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  CourseNickname.new(response)
  

end
remove_feature_flag_accounts(account_id,feature,opts={}) click to toggle source

Remove feature flag

# File lib/pandarus/v1_api.rb, line 11782
def remove_feature_flag_accounts(account_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/features/flags/{feature}",
    :account_id => account_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
remove_feature_flag_courses(course_id,feature,opts={}) click to toggle source

Remove feature flag

# File lib/pandarus/v1_api.rb, line 11745
def remove_feature_flag_courses(course_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/features/flags/{feature}",
    :course_id => course_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
remove_feature_flag_users(user_id,feature,opts={}) click to toggle source

Remove feature flag

# File lib/pandarus/v1_api.rb, line 11819
def remove_feature_flag_users(user_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/features/flags/{feature}",
    :user_id => user_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
remove_group_from_favorites(id,opts={}) click to toggle source

Remove group from favorites

# File lib/pandarus/v1_api.rb, line 11219
def remove_group_from_favorites(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/self/favorites/groups/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  Favorite.new(response)
  

end
remove_observee(user_id,observee_id,opts={}) click to toggle source

Remove an observee

# File lib/pandarus/v1_api.rb, line 25197
def remove_observee(user_id,observee_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "observee_id is required" if observee_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :observee_id => observee_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/observees/{observee_id}",
    :user_id => user_id,
    :observee_id => observee_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  User.new(response)
  

end
remove_usage_rights_courses(course_id,file_ids,opts={}) click to toggle source

Remove usage rights

# File lib/pandarus/v1_api.rb, line 13331
def remove_usage_rights_courses(course_id,file_ids,opts={})
  query_param_keys = [
    :file_ids,
    :folder_ids

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "file_ids is required" if file_ids.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :file_ids => file_ids

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/usage_rights",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
remove_usage_rights_groups(group_id,file_ids,opts={}) click to toggle source

Remove usage rights

# File lib/pandarus/v1_api.rb, line 13368
def remove_usage_rights_groups(group_id,file_ids,opts={})
  query_param_keys = [
    :file_ids,
    :folder_ids

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "file_ids is required" if file_ids.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :file_ids => file_ids

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/usage_rights",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
remove_usage_rights_users(user_id,file_ids,opts={}) click to toggle source

Remove usage rights

# File lib/pandarus/v1_api.rb, line 13405
def remove_usage_rights_users(user_id,file_ids,opts={})
  query_param_keys = [
    :file_ids,
    :folder_ids

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "file_ids is required" if file_ids.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :file_ids => file_ids

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/usage_rights",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
reorder_custom_columns(course_id,order,opts={}) click to toggle source

Reorder custom columns

# File lib/pandarus/v1_api.rb, line 7978
def reorder_custom_columns(course_id,order,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :order,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "order is required" if order.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :order => order

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/custom_gradebook_columns/reorder",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
reorder_pinned_topics_courses(course_id,order,opts={}) click to toggle source

Reorder pinned topics

# File lib/pandarus/v1_api.rb, line 8456
def reorder_pinned_topics_courses(course_id,order,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :order,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "order is required" if order.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :order => order

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/reorder",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
reorder_pinned_topics_groups(group_id,order,opts={}) click to toggle source

Reorder pinned topics

# File lib/pandarus/v1_api.rb, line 8493
def reorder_pinned_topics_groups(group_id,order,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :order,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "order is required" if order.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :order => order

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/reorder",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
reorder_question_groups(course_id,quiz_id,id,order__id__,opts={}) click to toggle source

Reorder question groups

# File lib/pandarus/v1_api.rb, line 21409
def reorder_question_groups(course_id,quiz_id,id,order__id__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :order__id__,
    :order__type__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  raise "order__id__ is required" if order__id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id,
    :order__id__ => order__id__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/groups/{id}/reorder",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
reorder_quiz_items(course_id,id,order__id__,opts={}) click to toggle source

Reorder quiz items

# File lib/pandarus/v1_api.rb, line 22676
def reorder_quiz_items(course_id,id,order__id__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :order__id__,
    :order__type__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  raise "order__id__ is required" if order__id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id,
    :order__id__ => order__id__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{id}/reorder",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
reserve_time_slot(id,opts={}) click to toggle source

Reserve a time slot

# File lib/pandarus/v1_api.rb, line 4055
def reserve_time_slot(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :participant_id,
    :comments,
    :cancel_existing,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/calendar_events/{id}/reservations",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
reserve_time_slot_participant_id(id,participant_id,opts={}) click to toggle source

Reserve a time slot

# File lib/pandarus/v1_api.rb, line 4092
def reserve_time_slot_participant_id(id,participant_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :comments,
    :cancel_existing,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "participant_id is required" if participant_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :participant_id => participant_id

  )

  # resource path
  path = path_replace("/v1/calendar_events/{id}/reservations/{participant_id}",
    :id => id,
    :participant_id => participant_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
reset_course(course_id,opts={}) click to toggle source

Reset a course

# File lib/pandarus/v1_api.rb, line 7655
def reset_course(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/reset_content",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Course.new(response)
  

end
reset_course_favorites(opts={}) click to toggle source

Reset course favorites

# File lib/pandarus/v1_api.rb, line 11253
def reset_course_favorites(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/favorites/courses",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
reset_group_favorites(opts={}) click to toggle source

Reset group favorites

# File lib/pandarus/v1_api.rb, line 11286
def reset_group_favorites(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/users/self/favorites/groups",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
resolve_path_courses(course_id,opts={}) click to toggle source

Resolve path

# File lib/pandarus/v1_api.rb, line 12529
def resolve_path_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/folders/by_path",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
resolve_path_courses_full_path(course_id,opts={}) click to toggle source

Resolve path

# File lib/pandarus/v1_api.rb, line 12496
def resolve_path_courses_full_path(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/folders/by_path/*full_path",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
resolve_path_groups(group_id,opts={}) click to toggle source

Resolve path

# File lib/pandarus/v1_api.rb, line 12661
def resolve_path_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/folders/by_path",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
resolve_path_groups_full_path(group_id,opts={}) click to toggle source

Resolve path

# File lib/pandarus/v1_api.rb, line 12628
def resolve_path_groups_full_path(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/folders/by_path/*full_path",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
resolve_path_users(user_id,opts={}) click to toggle source

Resolve path

# File lib/pandarus/v1_api.rb, line 12595
def resolve_path_users(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/folders/by_path",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
resolve_path_users_full_path(user_id,opts={}) click to toggle source

Resolve path

# File lib/pandarus/v1_api.rb, line 12562
def resolve_path_users_full_path(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/folders/by_path/*full_path",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, Folder, path, query_params)
  

end
retrieve_all_quiz_reports(course_id,quiz_id,opts={}) click to toggle source

Retrieve all quiz reports

# File lib/pandarus/v1_api.rb, line 21669
def retrieve_all_quiz_reports(course_id,quiz_id,opts={})
  query_param_keys = [
    :includes_all_versions

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/reports",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, QuizReport, path, query_params)
  

end
retrieve_assignment_overridden_dates_for_quizzes(course_id,opts={}) click to toggle source

Retrieve assignment-overridden dates for quizzes

# File lib/pandarus/v1_api.rb, line 21129
def retrieve_assignment_overridden_dates_for_quizzes(course_id,opts={})
  query_param_keys = [
    :quiz_assignment_overrides__0____quiz_ids__

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/assignment_overrides",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  QuizAssignmentOverrideSetContainer.new(response)
  

end
retrieve_captured_events(course_id,quiz_id,id,opts={}) click to toggle source

Retrieve captured events

# File lib/pandarus/v1_api.rb, line 21907
def retrieve_captured_events(course_id,quiz_id,id,opts={})
  query_param_keys = [
    :attempt

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions/{id}/events",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
returns_terms_of_service_for_that_account(account_id,opts={}) click to toggle source

Returns the terms of service for that account

# File lib/pandarus/v1_api.rb, line 575
def returns_terms_of_service_for_that_account(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/terms_of_service",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  TermsOfService.new(response)
  

end
revert_to_revision_courses(course_id,url,revision_id,opts={}) click to toggle source

Revert to revision

# File lib/pandarus/v1_api.rb, line 19537
def revert_to_revision_courses(course_id,url,revision_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  raise "revision_id is required" if revision_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url,
    :revision_id => revision_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages/{url}/revisions/{revision_id}",
    :course_id => course_id,
    :url => url,
    :revision_id => revision_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  PageRevision.new(response)
  

end
revert_to_revision_groups(group_id,url,revision_id,opts={}) click to toggle source

Revert to revision

# File lib/pandarus/v1_api.rb, line 19577
def revert_to_revision_groups(group_id,url,revision_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "url is required" if url.nil?
  raise "revision_id is required" if revision_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :url => url,
    :revision_id => revision_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages/{url}/revisions/{revision_id}",
    :group_id => group_id,
    :url => url,
    :revision_id => revision_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  PageRevision.new(response)
  

end
search_account_domains(opts={}) click to toggle source

Search account domains

# File lib/pandarus/v1_api.rb, line 13
def search_account_domains(opts={})
  query_param_keys = [
    :name,
    :domain,
    :latitude,
    :longitude

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/accounts/search",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
select_mastery_path(course_id,module_id,id,opts={}) click to toggle source

Select a mastery path

# File lib/pandarus/v1_api.rb, line 16576
def select_mastery_path(course_id,module_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :assignment_set_id,
    :student_id,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module_id is required" if module_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module_id => module_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{module_id}/items/{id}/select_mastery_path",
    :course_id => course_id,
    :module_id => module_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
select_provisional_grade(course_id,assignment_id,provisional_grade_id,opts={}) click to toggle source

Select provisional grade

# File lib/pandarus/v1_api.rb, line 16047
def select_provisional_grade(course_id,assignment_id,provisional_grade_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "provisional_grade_id is required" if provisional_grade_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :provisional_grade_id => provisional_grade_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/provisional_grades/{provisional_grade_id}/select",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :provisional_grade_id => provisional_grade_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
select_students_for_moderation(course_id,assignment_id,opts={}) click to toggle source

Select students for moderation

# File lib/pandarus/v1_api.rb, line 15973
def select_students_for_moderation(course_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :student_ids,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/moderated_students",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
self_register_user(account_id,user__name__,user__terms_of_use__,pseudonym__unique_id__,opts={}) click to toggle source

Self register a user

# File lib/pandarus/v1_api.rb, line 25659
def self_register_user(account_id,user__name__,user__terms_of_use__,pseudonym__unique_id__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user__name__,
    :user__short_name__,
    :user__sortable_name__,
    :user__time_zone__,
    :user__locale__,
    :user__birthdate__,
    :user__terms_of_use__,
    :pseudonym__unique_id__,
    :communication_channel__type__,
    :communication_channel__address__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "user__name__ is required" if user__name__.nil?
  raise "user__terms_of_use__ is required" if user__terms_of_use__.nil?
  raise "pseudonym__unique_id__ is required" if pseudonym__unique_id__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :user__name__ => user__name__,
    :user__terms_of_use__ => user__terms_of_use__,
    :pseudonym__unique_id__ => pseudonym__unique_id__

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/self_registration",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  User.new(response)
  

end
send_message_to_unsubmitted_or_submitted_users_for_quiz(course_id,id,opts={}) click to toggle source

Send a message to unsubmitted or submitted users for the quiz

# File lib/pandarus/v1_api.rb, line 22149
def send_message_to_unsubmitted_or_submitted_users_for_quiz(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :conversations,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{id}/submission_users/message",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
set_course_nickname(course_id,nickname,opts={}) click to toggle source

Set course nickname

# File lib/pandarus/v1_api.rb, line 26352
def set_course_nickname(course_id,nickname,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :nickname,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "nickname is required" if nickname.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :nickname => nickname

  )

  # resource path
  path = path_replace("/v1/users/self/course_nicknames/{course_id}",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  CourseNickname.new(response)
  

end
set_course_timetable(course_id,opts={}) click to toggle source

Set a course timetable

# File lib/pandarus/v1_api.rb, line 4210
def set_course_timetable(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :timetables__course_section_id__,
    :timetables__course_section_id____weekdays__,
    :timetables__course_section_id____start_time__,
    :timetables__course_section_id____end_time__,
    :timetables__course_section_id____location_name__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/calendar_events/timetable",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
set_extensions_for_student_quiz_submissions(course_id,user_id,opts={}) click to toggle source

Set extensions for student quiz submissions

# File lib/pandarus/v1_api.rb, line 6828
def set_extensions_for_student_quiz_submissions(course_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user_id,
    :extra_attempts,
    :extra_time,
    :manually_unlocked,
    :extend_from_now,
    :extend_from_end_at,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quiz_extensions",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
set_extensions_for_student_quiz_submissions_V1_0(course_id,quiz_id,user_id,opts={}) click to toggle source

Set extensions for student quiz submissions

# File lib/pandarus/v1_api.rb, line 21163
def set_extensions_for_student_quiz_submissions_V1_0(course_id,quiz_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :user_id,
    :extra_attempts,
    :extra_time,
    :manually_unlocked,
    :extend_from_now,
    :extend_from_end_at,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/extensions",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
set_feature_flag_accounts(account_id,feature,opts={}) click to toggle source

Set feature flag

# File lib/pandarus/v1_api.rb, line 11669
def set_feature_flag_accounts(account_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :state,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/features/flags/{feature}",
    :account_id => account_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
set_feature_flag_courses(course_id,feature,opts={}) click to toggle source

Set feature flag

# File lib/pandarus/v1_api.rb, line 11631
def set_feature_flag_courses(course_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :state,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/features/flags/{feature}",
    :course_id => course_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
set_feature_flag_users(user_id,feature,opts={}) click to toggle source

Set feature flag

# File lib/pandarus/v1_api.rb, line 11707
def set_feature_flag_users(user_id,feature,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :state,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "feature is required" if feature.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :feature => feature

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/features/flags/{feature}",
    :user_id => user_id,
    :feature => feature)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  FeatureFlag.new(response)
  

end
set_or_remove_restrictions_on_blueprint_course_object(course_id,template_id,opts={}) click to toggle source

Set or remove restrictions on a blueprint course object

# File lib/pandarus/v1_api.rb, line 3380
def set_or_remove_restrictions_on_blueprint_course_object(course_id,template_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :content_type,
    :content_id,
    :restricted,
    :restrictions,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}/restrict_item",
    :course_id => course_id,
    :template_id => template_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
set_usage_rights_courses(course_id,file_ids,usage_rights__use_justification__,opts={}) click to toggle source

Set usage rights

# File lib/pandarus/v1_api.rb, line 13199
def set_usage_rights_courses(course_id,file_ids,usage_rights__use_justification__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :file_ids,
    :folder_ids,
    :publish,
    :usage_rights__use_justification__,
    :usage_rights__legal_copyright__,
    :usage_rights__license__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "file_ids is required" if file_ids.nil?
  raise "usage_rights__use_justification__ is required" if usage_rights__use_justification__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :file_ids => file_ids,
    :usage_rights__use_justification__ => usage_rights__use_justification__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/usage_rights",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  UsageRights.new(response)
  

end
set_usage_rights_groups(group_id,file_ids,usage_rights__use_justification__,opts={}) click to toggle source

Set usage rights

# File lib/pandarus/v1_api.rb, line 13243
def set_usage_rights_groups(group_id,file_ids,usage_rights__use_justification__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :file_ids,
    :folder_ids,
    :publish,
    :usage_rights__use_justification__,
    :usage_rights__legal_copyright__,
    :usage_rights__license__,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "file_ids is required" if file_ids.nil?
  raise "usage_rights__use_justification__ is required" if usage_rights__use_justification__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :file_ids => file_ids,
    :usage_rights__use_justification__ => usage_rights__use_justification__

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/usage_rights",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  UsageRights.new(response)
  

end
set_usage_rights_users(user_id,file_ids,usage_rights__use_justification__,opts={}) click to toggle source

Set usage rights

# File lib/pandarus/v1_api.rb, line 13287
def set_usage_rights_users(user_id,file_ids,usage_rights__use_justification__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :file_ids,
    :folder_ids,
    :publish,
    :usage_rights__use_justification__,
    :usage_rights__legal_copyright__,
    :usage_rights__license__,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "file_ids is required" if file_ids.nil?
  raise "usage_rights__use_justification__ is required" if usage_rights__use_justification__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :file_ids => file_ids,
    :usage_rights__use_justification__ => usage_rights__use_justification__

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/usage_rights",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  UsageRights.new(response)
  

end
share_brandconfig_theme(account_id,shared_brand_config__name__,shared_brand_config__brand_config_md5__,opts={}) click to toggle source

Share a BrandConfig (Theme)

# File lib/pandarus/v1_api.rb, line 23798
def share_brandconfig_theme(account_id,shared_brand_config__name__,shared_brand_config__brand_config_md5__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :shared_brand_config__name__,
    :shared_brand_config__brand_config_md5__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "shared_brand_config__name__ is required" if shared_brand_config__name__.nil?
  raise "shared_brand_config__brand_config_md5__ is required" if shared_brand_config__brand_config_md5__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :shared_brand_config__name__ => shared_brand_config__name__,
    :shared_brand_config__brand_config_md5__ => shared_brand_config__brand_config_md5__

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/shared_brand_configs",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  SharedBrandConfig.new(response)
  

end
show_account_auth_settings(account_id,opts={}) click to toggle source

show account auth settings

# File lib/pandarus/v1_api.rb, line 3055
def show_account_auth_settings(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sso_settings",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  SSOSettings.new(response)
  

end
show_blueprint_import(course_id,subscription_id,id,opts={}) click to toggle source

Show a blueprint import

# File lib/pandarus/v1_api.rb, line 3608
def show_blueprint_import(course_id,subscription_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "subscription_id is required" if subscription_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :subscription_id => subscription_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_subscriptions/{subscription_id}/migrations/{id}",
    :course_id => course_id,
    :subscription_id => subscription_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  BlueprintMigration.new(response)
  

end
show_blueprint_migration(course_id,template_id,id,opts={}) click to toggle source

Show a blueprint migration

# File lib/pandarus/v1_api.rb, line 3493
def show_blueprint_migration(course_id,template_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}/migrations/{id}",
    :course_id => course_id,
    :template_id => template_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  BlueprintMigration.new(response)
  

end
show_content_export_courses(course_id,id,opts={}) click to toggle source

Show content export

# File lib/pandarus/v1_api.rb, line 4840
def show_content_export_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_exports/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ContentExport.new(response)
  

end
show_content_export_groups(group_id,id,opts={}) click to toggle source

Show content export

# File lib/pandarus/v1_api.rb, line 4877
def show_content_export_groups(group_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_exports/{id}",
    :group_id => group_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ContentExport.new(response)
  

end
show_content_export_users(user_id,id,opts={}) click to toggle source

Show content export

# File lib/pandarus/v1_api.rb, line 4914
def show_content_export_users(user_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_exports/{id}",
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ContentExport.new(response)
  

end
show_epub_export(course_id,id,opts={}) click to toggle source

Show ePub export

# File lib/pandarus/v1_api.rb, line 26522
def show_epub_export(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/epub_exports/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  EpubExport.new(response)
  

end
show_front_page_courses(course_id,opts={}) click to toggle source

Show front page

# File lib/pandarus/v1_api.rb, line 18738
def show_front_page_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/front_page",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Page.new(response)
  

end
show_front_page_groups(group_id,opts={}) click to toggle source

Show front page

# File lib/pandarus/v1_api.rb, line 18772
def show_front_page_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/front_page",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Page.new(response)
  

end
show_global_notification(account_id,user_id,id,opts={}) click to toggle source

Show a global notification

# File lib/pandarus/v1_api.rb, line 85
def show_global_notification(account_id,user_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/users/{user_id}/account_notifications/{id}",
    :account_id => account_id,
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  AccountNotification.new(response)
  

end
show_module(course_id,id,opts={}) click to toggle source

Show module

# File lib/pandarus/v1_api.rb, line 16199
def show_module(course_id,id,opts={})
  query_param_keys = [
    :include,
    :student_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Module.new(response)
  

end
show_module_item(course_id,module_id,id,opts={}) click to toggle source

Show module item

# File lib/pandarus/v1_api.rb, line 16435
def show_module_item(course_id,module_id,id,opts={})
  query_param_keys = [
    :include,
    :student_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module_id is required" if module_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module_id => module_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{module_id}/items/{id}",
    :course_id => course_id,
    :module_id => module_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  ModuleItem.new(response)
  

end
show_observee(user_id,observee_id,opts={}) click to toggle source

Show an observee

# File lib/pandarus/v1_api.rb, line 25123
def show_observee(user_id,observee_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "observee_id is required" if observee_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :observee_id => observee_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/observees/{observee_id}",
    :user_id => user_id,
    :observee_id => observee_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  User.new(response)
  

end
show_outcome(id,opts={}) click to toggle source

Show an outcome

# File lib/pandarus/v1_api.rb, line 18661
def show_outcome(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/outcomes/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Outcome.new(response)
  

end
show_outcome_group_accounts(account_id,id,opts={}) click to toggle source

Show an outcome group

# File lib/pandarus/v1_api.rb, line 17437
def show_outcome_group_accounts(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/outcome_groups/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
show_outcome_group_courses(course_id,id,opts={}) click to toggle source

Show an outcome group

# File lib/pandarus/v1_api.rb, line 17474
def show_outcome_group_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_groups/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
show_outcome_group_global(id,opts={}) click to toggle source

Show an outcome group

# File lib/pandarus/v1_api.rb, line 17403
def show_outcome_group_global(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/global/outcome_groups/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
show_page_courses(course_id,url,opts={}) click to toggle source

Show page

# File lib/pandarus/v1_api.rb, line 19077
def show_page_courses(course_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages/{url}",
    :course_id => course_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Page.new(response)
  

end
show_page_groups(group_id,url,opts={}) click to toggle source

Show page

# File lib/pandarus/v1_api.rb, line 19114
def show_page_groups(group_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages/{url}",
    :group_id => group_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Page.new(response)
  

end
show_planner_override(id,opts={}) click to toggle source

Show a planner override

# File lib/pandarus/v1_api.rb, line 20183
def show_planner_override(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/planner/overrides/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  PlannerOverride.new(response)
  

end
show_plannernote(id,opts={}) click to toggle source

Show a PlannerNote

# File lib/pandarus/v1_api.rb, line 19971
def show_plannernote(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/planner_notes/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  PlannerNote.new(response)
  

end
show_provisional_grade_status_for_student(course_id,assignment_id,opts={}) click to toggle source

Show provisional grade status for a student

# File lib/pandarus/v1_api.rb, line 16010
def show_provisional_grade_status_for_student(course_id,assignment_id,opts={})
  query_param_keys = [
    :student_id

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/provisional_grades/status",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
show_revision_courses_latest(course_id,url,opts={}) click to toggle source

Show revision

# File lib/pandarus/v1_api.rb, line 19383
def show_revision_courses_latest(course_id,url,opts={})
  query_param_keys = [
    :summary

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages/{url}/revisions/latest",
    :course_id => course_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  PageRevision.new(response)
  

end
show_revision_courses_revision_id(course_id,url,revision_id,opts={}) click to toggle source

Show revision

# File lib/pandarus/v1_api.rb, line 19457
def show_revision_courses_revision_id(course_id,url,revision_id,opts={})
  query_param_keys = [
    :summary

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  raise "revision_id is required" if revision_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url,
    :revision_id => revision_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages/{url}/revisions/{revision_id}",
    :course_id => course_id,
    :url => url,
    :revision_id => revision_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  PageRevision.new(response)
  

end
show_revision_groups_latest(group_id,url,opts={}) click to toggle source

Show revision

# File lib/pandarus/v1_api.rb, line 19420
def show_revision_groups_latest(group_id,url,opts={})
  query_param_keys = [
    :summary

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages/{url}/revisions/latest",
    :group_id => group_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  PageRevision.new(response)
  

end
show_revision_groups_revision_id(group_id,url,revision_id,opts={}) click to toggle source

Show revision

# File lib/pandarus/v1_api.rb, line 19497
def show_revision_groups_revision_id(group_id,url,revision_id,opts={})
  query_param_keys = [
    :summary

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "url is required" if url.nil?
  raise "revision_id is required" if revision_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :url => url,
    :revision_id => revision_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages/{url}/revisions/{revision_id}",
    :group_id => group_id,
    :url => url,
    :revision_id => revision_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  PageRevision.new(response)
  

end
show_user_details(id,opts={}) click to toggle source

Show user details

# File lib/pandarus/v1_api.rb, line 25568
def show_user_details(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  User.new(response)
  

end
split_merged_users_into_separate_users(id,opts={}) click to toggle source

Split merged users into separate users

# File lib/pandarus/v1_api.rb, line 26040
def split_merged_users_into_separate_users(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{id}/split",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  RemoteCollection.new(connection, User, path, query_params)
  

end
start_kaltura_session(opts={}) click to toggle source

Start Kaltura session

# File lib/pandarus/v1_api.rb, line 23765
def start_kaltura_session(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/services/kaltura_session",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
start_report(account_id,report,opts={}) click to toggle source

Start a Report

# File lib/pandarus/v1_api.rb, line 290
def start_report(account_id,report,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :__parameters__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "report is required" if report.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :report => report

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/reports/{report}",
    :account_id => account_id,
    :report => report)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  Report.new(response)
  

end
status_of_report(account_id,report,id,opts={}) click to toggle source

Status of a Report

# File lib/pandarus/v1_api.rb, line 364
def status_of_report(account_id,report,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "report is required" if report.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :report => report,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/reports/{report}/{id}",
    :account_id => account_id,
    :report => report,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  Report.new(response)
  

end
store_custom_data(user_id,ns,data,opts={}) click to toggle source

Store custom data

# File lib/pandarus/v1_api.rb, line 26174
def store_custom_data(user_id,ns,data,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :ns,
    :data,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "ns is required" if ns.nil?
  raise "data is required" if data.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :ns => ns,
    :data => data

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/custom_data",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
submission_summary_courses(course_id,assignment_id,opts={}) click to toggle source

Submission Summary

# File lib/pandarus/v1_api.rb, line 24872
def submission_summary_courses(course_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submission_summary",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
submission_summary_sections(section_id,assignment_id,opts={}) click to toggle source

Submission Summary

# File lib/pandarus/v1_api.rb, line 24909
def submission_summary_sections(section_id,assignment_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submission_summary",
    :section_id => section_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
submit_assignment_courses(course_id,assignment_id,submission__submission_type__,opts={}) click to toggle source

Submit an assignment

# File lib/pandarus/v1_api.rb, line 23949
def submit_assignment_courses(course_id,assignment_id,submission__submission_type__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :comment__text_comment__,
    :submission__submission_type__,
    :submission__body__,
    :submission__url__,
    :submission__file_ids__,
    :submission__media_comment_id__,
    :submission__media_comment_type__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "submission__submission_type__ is required" if submission__submission_type__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :submission__submission_type__ => submission__submission_type__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions",
    :course_id => course_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
submit_assignment_sections(section_id,assignment_id,submission__submission_type__,opts={}) click to toggle source

Submit an assignment

# File lib/pandarus/v1_api.rb, line 23995
def submit_assignment_sections(section_id,assignment_id,submission__submission_type__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :comment__text_comment__,
    :submission__submission_type__,
    :submission__body__,
    :submission__url__,
    :submission__file_ids__,
    :submission__media_comment_id__,
    :submission__media_comment_type__,
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "submission__submission_type__ is required" if submission__submission_type__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :submission__submission_type__ => submission__submission_type__

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions",
    :section_id => section_id,
    :assignment_id => assignment_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
submit_captured_events(course_id,quiz_id,id,quiz_submission_events,opts={}) click to toggle source

Submit captured events

# File lib/pandarus/v1_api.rb, line 21864
def submit_captured_events(course_id,quiz_id,id,quiz_submission_events,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :quiz_submission_events,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  raise "quiz_submission_events is required" if quiz_submission_events.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id,
    :quiz_submission_events => quiz_submission_events

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions/{id}/events",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
subscribe_to_topic_courses(course_id,topic_id,opts={}) click to toggle source

Subscribe to a topic

# File lib/pandarus/v1_api.rb, line 9772
def subscribe_to_topic_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/subscribed",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
subscribe_to_topic_groups(group_id,topic_id,opts={}) click to toggle source

Subscribe to a topic

# File lib/pandarus/v1_api.rb, line 9809
def subscribe_to_topic_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/subscribed",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
un_share_brandconfig_theme(id,opts={}) click to toggle source

Un-share a BrandConfig (Theme)

# File lib/pandarus/v1_api.rb, line 23875
def un_share_brandconfig_theme(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/shared_brand_configs/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  SharedBrandConfig.new(response)
  

end
unflagging_question(quiz_submission_id,id,attempt,validation_token,opts={}) click to toggle source

Unflagging a question.

# File lib/pandarus/v1_api.rb, line 22105
def unflagging_question(quiz_submission_id,id,attempt,validation_token,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :attempt,
    :validation_token,
    :access_code,
    

  ]

  # verify existence of params
  raise "quiz_submission_id is required" if quiz_submission_id.nil?
  raise "id is required" if id.nil?
  raise "attempt is required" if attempt.nil?
  raise "validation_token is required" if validation_token.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :quiz_submission_id => quiz_submission_id,
    :id => id,
    :attempt => attempt,
    :validation_token => validation_token

  )

  # resource path
  path = path_replace("/v1/quiz_submissions/{quiz_submission_id}/questions/{id}/unflag",
    :quiz_submission_id => quiz_submission_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
unread_count(opts={}) click to toggle source

Unread count

# File lib/pandarus/v1_api.rb, line 6761
def unread_count(opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # set default values and merge with input
  options = underscored_merge_opts(opts,
    {}
  

  )

  # resource path
  path = path_replace("/v1/conversations/unread_count",
    )
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
unsubscribe_from_topic_courses(course_id,topic_id,opts={}) click to toggle source

Unsubscribe from a topic

# File lib/pandarus/v1_api.rb, line 9846
def unsubscribe_from_topic_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/subscribed",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
unsubscribe_from_topic_groups(group_id,topic_id,opts={}) click to toggle source

Unsubscribe from a topic

# File lib/pandarus/v1_api.rb, line 9883
def unsubscribe_from_topic_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/subscribed",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:delete, path, query_params, form_params, headers)
  response
  

end
update_account(id,opts={}) click to toggle source

Update an account

# File lib/pandarus/v1_api.rb, line 657
def update_account(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :account__name__,
    :account__sis_account_id__,
    :account__default_time_zone__,
    :account__default_storage_quota_mb__,
    :account__default_user_storage_quota_mb__,
    :account__default_group_storage_quota_mb__,
    :account__settings____restrict_student_past_view____value__,
    :account__settings____restrict_student_past_view____locked__,
    :account__settings____restrict_student_future_view____value__,
    :account__settings____restrict_student_future_view____locked__,
    :account__settings____lock_all_announcements____value__,
    :account__settings____lock_all_announcements____locked__,
    :account__settings____restrict_student_future_listing____value__,
    :account__settings____restrict_student_future_listing____locked__,
    :account__services__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Account.new(response)
  

end
update_account_auth_settings(account_id,opts={}) click to toggle source

update account auth settings

# File lib/pandarus/v1_api.rb, line 3089
def update_account_auth_settings(account_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/sso_settings",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  SSOSettings.new(response)
  

end
update_appointment_group(id,appointment_group__context_codes__,opts={}) click to toggle source

Update an appointment group

# File lib/pandarus/v1_api.rb, line 1833
def update_appointment_group(id,appointment_group__context_codes__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :appointment_group__context_codes__,
    :appointment_group__sub_context_codes__,
    :appointment_group__title__,
    :appointment_group__description__,
    :appointment_group__location_name__,
    :appointment_group__location_address__,
    :appointment_group__publish__,
    :appointment_group__participants_per_appointment__,
    :appointment_group__min_appointments_per_participant__,
    :appointment_group__max_appointments_per_participant__,
    :appointment_group__new_appointments_____x__,
    :appointment_group__participant_visibility__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "appointment_group__context_codes__ is required" if appointment_group__context_codes__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :appointment_group__context_codes__ => appointment_group__context_codes__

  )

  # resource path
  path = path_replace("/v1/appointment_groups/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_assignment_override(course_id,assignment_id,id,opts={}) click to toggle source

Update an assignment override

# File lib/pandarus/v1_api.rb, line 2682
def update_assignment_override(course_id,assignment_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :assignment_override__student_ids__,
    :assignment_override__title__,
    :assignment_override__due_at__,
    :assignment_override__unlock_at__,
    :assignment_override__lock_at__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/overrides/{id}",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  AssignmentOverride.new(response)
  

end
update_associated_courses(course_id,template_id,opts={}) click to toggle source

Update associated courses

# File lib/pandarus/v1_api.rb, line 3301
def update_associated_courses(course_id,template_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :course_ids_to_add,
    :course_ids_to_remove,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "template_id is required" if template_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :template_id => template_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/blueprint_templates/{template_id}/update_associations",
    :course_id => course_id,
    :template_id => template_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_authentication_provider(account_id,id,opts={}) click to toggle source

Update authentication provider

# File lib/pandarus/v1_api.rb, line 2944
def update_authentication_provider(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/authentication_providers/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  AuthenticationProvider.new(response)
  

end
update_bookmark(id,opts={}) click to toggle source

Update bookmark

# File lib/pandarus/v1_api.rb, line 3790
def update_bookmark(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :url,
    :position,
    :data,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/self/bookmarks/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Folder.new(response)
  

end
update_calendar_event(id,opts={}) click to toggle source

Update a calendar event

# File lib/pandarus/v1_api.rb, line 4131
def update_calendar_event(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :calendar_event__context_code__,
    :calendar_event__title__,
    :calendar_event__description__,
    :calendar_event__start_at__,
    :calendar_event__end_at__,
    :calendar_event__location_name__,
    :calendar_event__location_address__,
    :calendar_event__time_zone_edited__,
    :calendar_event__child_event_data_____x____start_at__,
    :calendar_event__child_event_data_____x____end_at__,
    :calendar_event__child_event_data_____x____context_code__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/calendar_events/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_column_data(course_id,id,user_id,column_data__content__,opts={}) click to toggle source

Update column data

# File lib/pandarus/v1_api.rb, line 8051
def update_column_data(course_id,id,user_id,column_data__content__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :column_data__content__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  raise "user_id is required" if user_id.nil?
  raise "column_data__content__ is required" if column_data__content__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id,
    :user_id => user_id,
    :column_data__content__ => column_data__content__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/custom_gradebook_columns/{id}/data/{user_id}",
    :course_id => course_id,
    :id => id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  ColumnDatum.new(response)
  

end
update_content_migration_accounts(account_id,id,opts={}) click to toggle source

Update a content migration

# File lib/pandarus/v1_api.rb, line 6029
def update_content_migration_accounts(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/content_migrations/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
update_content_migration_courses(course_id,id,opts={}) click to toggle source

Update a content migration

# File lib/pandarus/v1_api.rb, line 6066
def update_content_migration_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_migrations/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
update_content_migration_groups(group_id,id,opts={}) click to toggle source

Update a content migration

# File lib/pandarus/v1_api.rb, line 6103
def update_content_migration_groups(group_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_migrations/{id}",
    :group_id => group_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
update_content_migration_users(user_id,id,opts={}) click to toggle source

Update a content migration

# File lib/pandarus/v1_api.rb, line 6140
def update_content_migration_users(user_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_migrations/{id}",
    :user_id => user_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  ContentMigration.new(response)
  

end
update_course(id,opts={}) click to toggle source

Update a course

# File lib/pandarus/v1_api.rb, line 7545
def update_course(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :course__account_id__,
    :course__name__,
    :course__course_code__,
    :course__start_at__,
    :course__end_at__,
    :course__license__,
    :course__is_public__,
    :course__is_public_to_auth_users__,
    :course__public_syllabus__,
    :course__public_syllabus_to_auth__,
    :course__public_description__,
    :course__allow_student_wiki_edits__,
    :course__allow_wiki_comments__,
    :course__allow_student_forum_attachments__,
    :course__open_enrollment__,
    :course__self_enrollment__,
    :course__restrict_enrollments_to_course_dates__,
    :course__term_id__,
    :course__sis_course_id__,
    :course__integration_id__,
    :course__hide_final_grades__,
    :course__time_zone__,
    :course__apply_assignment_group_weights__,
    :course__storage_quota_mb__,
    :offer,
    :course__event__,
    :course__syllabus_body__,
    :course__grading_standard_id__,
    :course__course_format__,
    :course__image_id__,
    :course__image_url__,
    :course__remove_image__,
    :course__blueprint__,
    :course__blueprint_restrictions__,
    :course__use_blueprint_restrictions_by_object_type__,
    :course__blueprint_restrictions_by_object_type__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_course_settings(course_id,opts={}) click to toggle source

Update course settings

# File lib/pandarus/v1_api.rb, line 7429
def update_course_settings(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :allow_student_discussion_topics,
    :allow_student_forum_attachments,
    :allow_student_discussion_editing,
    :allow_student_organized_groups,
    :hide_final_grades,
    :hide_distribution_graphs,
    :lock_all_announcements,
    :restrict_student_past_view,
    :restrict_student_future_view,
    :show_announcements_on_home_page,
    :home_page_announcement_limit,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/settings",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_courses(account_id,course_ids,event,opts={}) click to toggle source

Update courses

# File lib/pandarus/v1_api.rb, line 7615
def update_courses(account_id,course_ids,event,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :course_ids,
    :event,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "course_ids is required" if course_ids.nil?
  raise "event is required" if event.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :course_ids => course_ids,
    :event => event

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/courses",
    :account_id => account_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Progress.new(response)
  

end
update_create_front_page_courses(course_id,opts={}) click to toggle source

Update/create front page

# File lib/pandarus/v1_api.rb, line 18843
def update_create_front_page_courses(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :wiki_page__title__,
    :wiki_page__body__,
    :wiki_page__editing_roles__,
    :wiki_page__notify_of_update__,
    :wiki_page__published__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/front_page",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Page.new(response)
  

end
update_create_front_page_groups(group_id,opts={}) click to toggle source

Update/create front page

# File lib/pandarus/v1_api.rb, line 18882
def update_create_front_page_groups(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :wiki_page__title__,
    :wiki_page__body__,
    :wiki_page__editing_roles__,
    :wiki_page__notify_of_update__,
    :wiki_page__published__,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/front_page",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Page.new(response)
  

end
update_create_page_courses(course_id,url,opts={}) click to toggle source

Update/create page

# File lib/pandarus/v1_api.rb, line 19151
def update_create_page_courses(course_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :wiki_page__title__,
    :wiki_page__body__,
    :wiki_page__editing_roles__,
    :wiki_page__notify_of_update__,
    :wiki_page__published__,
    :wiki_page__front_page__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/pages/{url}",
    :course_id => course_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Page.new(response)
  

end
update_create_page_groups(group_id,url,opts={}) click to toggle source

Update/create page

# File lib/pandarus/v1_api.rb, line 19194
def update_create_page_groups(group_id,url,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :wiki_page__title__,
    :wiki_page__body__,
    :wiki_page__editing_roles__,
    :wiki_page__notify_of_update__,
    :wiki_page__published__,
    :wiki_page__front_page__,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "url is required" if url.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :url => url

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/pages/{url}",
    :group_id => group_id,
    :url => url)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Page.new(response)
  

end
update_custom_color(id,asset_string,opts={}) click to toggle source

Update custom color

# File lib/pandarus/v1_api.rb, line 25815
def update_custom_color(id,asset_string,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :hexcode,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "asset_string is required" if asset_string.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :asset_string => asset_string

  )

  # resource path
  path = path_replace("/v1/users/{id}/colors/{asset_string}",
    :id => id,
    :asset_string => asset_string)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_custom_gradebook_column(course_id,id,opts={}) click to toggle source

Update a custom gradebook column

# File lib/pandarus/v1_api.rb, line 7904
def update_custom_gradebook_column(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/custom_gradebook_columns/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  CustomColumn.new(response)
  

end
update_dashboard_positions(id,opts={}) click to toggle source

Update dashboard positions

# File lib/pandarus/v1_api.rb, line 25887
def update_dashboard_positions(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{id}/dashboard_positions",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_enrollment_term(account_id,id,opts={}) click to toggle source

Update enrollment term

# File lib/pandarus/v1_api.rb, line 9960
def update_enrollment_term(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :enrollment_term__name__,
    :enrollment_term__start_at__,
    :enrollment_term__end_at__,
    :enrollment_term__sis_term_id__,
    :enrollment_term__overrides____enrollment_type____start_at__,
    :enrollment_term__overrides____enrollment_type____end_at__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/terms/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  EnrollmentTerm.new(response)
  

end
update_entry_courses(course_id,topic_id,id,opts={}) click to toggle source

Update an entry

# File lib/pandarus/v1_api.rb, line 8530
def update_entry_courses(course_id,topic_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :message,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}/entries/{id}",
    :course_id => course_id,
    :topic_id => topic_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_entry_groups(group_id,topic_id,id,opts={}) click to toggle source

Update an entry

# File lib/pandarus/v1_api.rb, line 8571
def update_entry_groups(group_id,topic_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :message,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}/entries/{id}",
    :group_id => group_id,
    :topic_id => topic_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_existing_quiz_question(course_id,quiz_id,id,opts={}) click to toggle source

Update an existing quiz question

# File lib/pandarus/v1_api.rb, line 21578
def update_existing_quiz_question(course_id,quiz_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :question__question_name__,
    :question__question_text__,
    :question__quiz_group_id__,
    :question__question_type__,
    :question__position__,
    :question__points_possible__,
    :question__correct_comments__,
    :question__incorrect_comments__,
    :question__neutral_comments__,
    :question__text_after_answers__,
    :question__answers__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/questions/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  QuizQuestion.new(response)
  

end
update_file(id,opts={}) click to toggle source

Update file

# File lib/pandarus/v1_api.rb, line 12289
def update_file(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :parent_folder_id,
    :on_duplicate,
    :lock_at,
    :unlock_at,
    :locked,
    :hidden,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/files/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  File.new(response)
  

end
update_folder(id,opts={}) click to toggle source

Update folder

# File lib/pandarus/v1_api.rb, line 12839
def update_folder(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :parent_folder_id,
    :lock_at,
    :unlock_at,
    :locked,
    :hidden,
    :position,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/folders/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Folder.new(response)
  

end
update_global_notification(account_id,id,opts={}) click to toggle source

Update a global notification

# File lib/pandarus/v1_api.rb, line 213
def update_global_notification(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :account_notification__subject__,
    :account_notification__message__,
    :account_notification__start_at__,
    :account_notification__end_at__,
    :account_notification__icon__,
    :account_notification_roles,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/account_notifications/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_group_category(group_category_id,opts={}) click to toggle source

Update a Group Category

# File lib/pandarus/v1_api.rb, line 14456
def update_group_category(group_category_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :self_signup,
    :auto_leader,
    :group_limit,
    :create_group_count,
    :split_group_count,
    

  ]

  # verify existence of params
  raise "group_category_id is required" if group_category_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_category_id => group_category_id

  )

  # resource path
  path = path_replace("/v1/group_categories/{group_category_id}",
    :group_category_id => group_category_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  GroupCategory.new(response)
  

end
update_membership_memberships(group_id,membership_id,opts={}) click to toggle source

Update a membership

# File lib/pandarus/v1_api.rb, line 15269
def update_membership_memberships(group_id,membership_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :workflow_state,
    :moderator,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "membership_id is required" if membership_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :membership_id => membership_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/memberships/{membership_id}",
    :group_id => group_id,
    :membership_id => membership_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  GroupMembership.new(response)
  

end
update_membership_users(group_id,user_id,opts={}) click to toggle source

Update a membership

# File lib/pandarus/v1_api.rb, line 15308
def update_membership_users(group_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :workflow_state,
    :moderator,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/users/{user_id}",
    :group_id => group_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  GroupMembership.new(response)
  

end
update_migration_issue_accounts(account_id,content_migration_id,id,workflow_state,opts={}) click to toggle source

Update a migration issue

# File lib/pandarus/v1_api.rb, line 5369
def update_migration_issue_accounts(account_id,content_migration_id,id,workflow_state,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :workflow_state,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  raise "id is required" if id.nil?
  raise "workflow_state is required" if workflow_state.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :content_migration_id => content_migration_id,
    :id => id,
    :workflow_state => workflow_state

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/content_migrations/{content_migration_id}/migration_issues/{id}",
    :account_id => account_id,
    :content_migration_id => content_migration_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  MigrationIssue.new(response)
  

end
update_migration_issue_courses(course_id,content_migration_id,id,workflow_state,opts={}) click to toggle source

Update a migration issue

# File lib/pandarus/v1_api.rb, line 5412
def update_migration_issue_courses(course_id,content_migration_id,id,workflow_state,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :workflow_state,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  raise "id is required" if id.nil?
  raise "workflow_state is required" if workflow_state.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :content_migration_id => content_migration_id,
    :id => id,
    :workflow_state => workflow_state

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/content_migrations/{content_migration_id}/migration_issues/{id}",
    :course_id => course_id,
    :content_migration_id => content_migration_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  MigrationIssue.new(response)
  

end
update_migration_issue_groups(group_id,content_migration_id,id,workflow_state,opts={}) click to toggle source

Update a migration issue

# File lib/pandarus/v1_api.rb, line 5455
def update_migration_issue_groups(group_id,content_migration_id,id,workflow_state,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :workflow_state,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  raise "id is required" if id.nil?
  raise "workflow_state is required" if workflow_state.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :content_migration_id => content_migration_id,
    :id => id,
    :workflow_state => workflow_state

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/content_migrations/{content_migration_id}/migration_issues/{id}",
    :group_id => group_id,
    :content_migration_id => content_migration_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  MigrationIssue.new(response)
  

end
update_migration_issue_users(user_id,content_migration_id,id,workflow_state,opts={}) click to toggle source

Update a migration issue

# File lib/pandarus/v1_api.rb, line 5498
def update_migration_issue_users(user_id,content_migration_id,id,workflow_state,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :workflow_state,
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  raise "content_migration_id is required" if content_migration_id.nil?
  raise "id is required" if id.nil?
  raise "workflow_state is required" if workflow_state.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id,
    :content_migration_id => content_migration_id,
    :id => id,
    :workflow_state => workflow_state

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/content_migrations/{content_migration_id}/migration_issues/{id}",
    :user_id => user_id,
    :content_migration_id => content_migration_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  MigrationIssue.new(response)
  

end
update_module(course_id,id,opts={}) click to toggle source

Update a module

# File lib/pandarus/v1_api.rb, line 16279
def update_module(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :module__name__,
    :module__unlock_at__,
    :module__position__,
    :module__require_sequential_progress__,
    :module__prerequisite_module_ids__,
    :module__publish_final_grade__,
    :module__published__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Module.new(response)
  

end
update_module_item(course_id,module_id,id,opts={}) click to toggle source

Update a module item

# File lib/pandarus/v1_api.rb, line 16527
def update_module_item(course_id,module_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :module_item__title__,
    :module_item__position__,
    :module_item__indent__,
    :module_item__external_url__,
    :module_item__new_tab__,
    :module_item__completion_requirement____type__,
    :module_item__completion_requirement____min_score__,
    :module_item__published__,
    :module_item__module_id__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "module_id is required" if module_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :module_id => module_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/modules/{module_id}/items/{id}",
    :course_id => course_id,
    :module_id => module_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  ModuleItem.new(response)
  

end
update_multiple_preferences_communication_channel_id(communication_channel_id,notification_preferences____x_____frequency__,opts={}) click to toggle source

Update multiple preferences

# File lib/pandarus/v1_api.rb, line 17091
def update_multiple_preferences_communication_channel_id(communication_channel_id,notification_preferences____x_____frequency__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :notification_preferences____x_____frequency__,
    

  ]

  # verify existence of params
  raise "communication_channel_id is required" if communication_channel_id.nil?
  raise "notification_preferences____x_____frequency__ is required" if notification_preferences____x_____frequency__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :communication_channel_id => communication_channel_id,
    :notification_preferences____x_____frequency__ => notification_preferences____x_____frequency__

  )

  # resource path
  path = path_replace("/v1/users/self/communication_channels/{communication_channel_id}/notification_preferences",
    :communication_channel_id => communication_channel_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_multiple_preferences_type(type,address,notification_preferences____x_____frequency__,opts={}) click to toggle source

Update multiple preferences

# File lib/pandarus/v1_api.rb, line 17128
def update_multiple_preferences_type(type,address,notification_preferences____x_____frequency__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :notification_preferences____x_____frequency__,
    

  ]

  # verify existence of params
  raise "type is required" if type.nil?
  raise "address is required" if address.nil?
  raise "notification_preferences____x_____frequency__ is required" if notification_preferences____x_____frequency__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :type => type,
    :address => address,
    :notification_preferences____x_____frequency__ => notification_preferences____x_____frequency__

  )

  # resource path
  path = path_replace("/v1/users/self/communication_channels/{type}/{address}/notification_preferences",
    :type => type,
    :address => address)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_outcome(id,opts={}) click to toggle source

Update an outcome

# File lib/pandarus/v1_api.rb, line 18695
def update_outcome(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :display_name,
    :description,
    :vendor_guid,
    :mastery_points,
    :ratings__description__,
    :ratings__points__,
    :calculation_method,
    :calculation_int,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/outcomes/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Outcome.new(response)
  

end
update_outcome_group_accounts(account_id,id,opts={}) click to toggle source

Update an outcome group

# File lib/pandarus/v1_api.rb, line 17549
def update_outcome_group_accounts(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :description,
    :vendor_guid,
    :parent_outcome_group_id,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/outcome_groups/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
update_outcome_group_courses(course_id,id,opts={}) click to toggle source

Update an outcome group

# File lib/pandarus/v1_api.rb, line 17590
def update_outcome_group_courses(course_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :description,
    :vendor_guid,
    :parent_outcome_group_id,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/outcome_groups/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
update_outcome_group_global(id,opts={}) click to toggle source

Update an outcome group

# File lib/pandarus/v1_api.rb, line 17511
def update_outcome_group_global(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :description,
    :vendor_guid,
    :parent_outcome_group_id,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/global/outcome_groups/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  OutcomeGroup.new(response)
  

end
update_planner_override(id,opts={}) click to toggle source

Update a planner override

# File lib/pandarus/v1_api.rb, line 20217
def update_planner_override(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :marked_complete,
    :dismissed,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/planner/overrides/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  PlannerOverride.new(response)
  

end
update_plannernote(id,opts={}) click to toggle source

Update a PlannerNote

# File lib/pandarus/v1_api.rb, line 20005
def update_plannernote(id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :details,
    :todo_date,
    :course_id,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/planner_notes/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  PlannerNote.new(response)
  

end
update_preference_communication_channel_id(communication_channel_id,notification,notification_preferences__frequency__,opts={}) click to toggle source

Update a preference

# File lib/pandarus/v1_api.rb, line 16968
def update_preference_communication_channel_id(communication_channel_id,notification,notification_preferences__frequency__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :notification_preferences__frequency__,
    

  ]

  # verify existence of params
  raise "communication_channel_id is required" if communication_channel_id.nil?
  raise "notification is required" if notification.nil?
  raise "notification_preferences__frequency__ is required" if notification_preferences__frequency__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :communication_channel_id => communication_channel_id,
    :notification => notification,
    :notification_preferences__frequency__ => notification_preferences__frequency__

  )

  # resource path
  path = path_replace("/v1/users/self/communication_channels/{communication_channel_id}/notification_preferences/{notification}",
    :communication_channel_id => communication_channel_id,
    :notification => notification)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_preference_type(type,address,notification,notification_preferences__frequency__,opts={}) click to toggle source

Update a preference

# File lib/pandarus/v1_api.rb, line 17008
def update_preference_type(type,address,notification,notification_preferences__frequency__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :notification_preferences__frequency__,
    

  ]

  # verify existence of params
  raise "type is required" if type.nil?
  raise "address is required" if address.nil?
  raise "notification is required" if notification.nil?
  raise "notification_preferences__frequency__ is required" if notification_preferences__frequency__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :type => type,
    :address => address,
    :notification => notification,
    :notification_preferences__frequency__ => notification_preferences__frequency__

  )

  # resource path
  path = path_replace("/v1/users/self/communication_channels/{type}/{address}/notification_preferences/{notification}",
    :type => type,
    :address => address,
    :notification => notification)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_preferences_by_category(communication_channel_id,category,notification_preferences__frequency__,opts={}) click to toggle source

Update preferences by category

# File lib/pandarus/v1_api.rb, line 17051
def update_preferences_by_category(communication_channel_id,category,notification_preferences__frequency__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :notification_preferences__frequency__,
    

  ]

  # verify existence of params
  raise "communication_channel_id is required" if communication_channel_id.nil?
  raise "category is required" if category.nil?
  raise "notification_preferences__frequency__ is required" if notification_preferences__frequency__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :communication_channel_id => communication_channel_id,
    :category => category,
    :notification_preferences__frequency__ => notification_preferences__frequency__

  )

  # resource path
  path = path_replace("/v1/users/self/communication_channels/{communication_channel_id}/notification_preference_categories/{category}",
    :communication_channel_id => communication_channel_id,
    :category => category)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_question_group(course_id,quiz_id,id,opts={}) click to toggle source

Update a question group

# File lib/pandarus/v1_api.rb, line 21326
def update_question_group(course_id,quiz_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :quiz_groups__name__,
    :quiz_groups__pick_count__,
    :quiz_groups__question_points__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/groups/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_role(account_id,id,opts={}) click to toggle source

Update a role

# File lib/pandarus/v1_api.rb, line 22956
def update_role(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :label,
    :permissions____x_____explicit__,
    :permissions____x_____enabled__,
    :permissions____x_____applies_to_self__,
    :permissions____x_____applies_to_descendants__,
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/roles/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Role.new(response)
  

end
update_shared_theme(account_id,id,opts={}) click to toggle source

Update a shared theme

# File lib/pandarus/v1_api.rb, line 23838
def update_shared_theme(account_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "account_id is required" if account_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :account_id => account_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/accounts/{account_id}/shared_brand_configs/{id}",
    :account_id => account_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  SharedBrandConfig.new(response)
  

end
update_single_grading_period(course_id,id,grading_periods__start_date__,grading_periods__end_date__,opts={}) click to toggle source

Update a single grading period

# File lib/pandarus/v1_api.rb, line 13928
def update_single_grading_period(course_id,id,grading_periods__start_date__,grading_periods__end_date__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :grading_periods__start_date__,
    :grading_periods__end_date__,
    :grading_periods__weight__,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  raise "grading_periods__start_date__ is required" if grading_periods__start_date__.nil?
  raise "grading_periods__end_date__ is required" if grading_periods__end_date__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id,
    :grading_periods__start_date__ => grading_periods__start_date__,
    :grading_periods__end_date__ => grading_periods__end_date__

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/grading_periods/{id}",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_single_poll(id,polls__question__,opts={}) click to toggle source

Update a single poll

# File lib/pandarus/v1_api.rb, line 21023
def update_single_poll(id,polls__question__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :polls__question__,
    :polls__description__,
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  raise "polls__question__ is required" if polls__question__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id,
    :polls__question__ => polls__question__

  )

  # resource path
  path = path_replace("/v1/polls/{id}",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_single_poll_choice(poll_id,id,poll_choices__text__,opts={}) click to toggle source

Update a single poll choice

# File lib/pandarus/v1_api.rb, line 20761
def update_single_poll_choice(poll_id,id,poll_choices__text__,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :poll_choices__text__,
    :poll_choices__is_correct__,
    :poll_choices__position__,
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "id is required" if id.nil?
  raise "poll_choices__text__ is required" if poll_choices__text__.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :id => id,
    :poll_choices__text__ => poll_choices__text__

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_choices/{id}",
    :poll_id => poll_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_single_poll_session(poll_id,id,opts={}) click to toggle source

Update a single poll session

# File lib/pandarus/v1_api.rb, line 20434
def update_single_poll_session(poll_id,id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :poll_sessions__course_id__,
    :poll_sessions__course_section_id__,
    :poll_sessions__has_public_results__,
    

  ]

  # verify existence of params
  raise "poll_id is required" if poll_id.nil?
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :poll_id => poll_id,
    :id => id

  )

  # resource path
  path = path_replace("/v1/polls/{poll_id}/poll_sessions/{id}",
    :poll_id => poll_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_student_question_scores_and_comments(course_id,quiz_id,id,attempt,opts={}) click to toggle source

Update student question scores and comments.

# File lib/pandarus/v1_api.rb, line 22340
def update_student_question_scores_and_comments(course_id,quiz_id,id,attempt,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :attempt,
    :fudge_points,
    :questions,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  raise "id is required" if id.nil?
  raise "attempt is required" if attempt.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id,
    :attempt => attempt

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions/{id}",
    :course_id => course_id,
    :quiz_id => quiz_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_tab_for_course(course_id,tab_id,opts={}) click to toggle source

Update a tab for a course

# File lib/pandarus/v1_api.rb, line 25014
def update_tab_for_course(course_id,tab_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :position,
    :hidden,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "tab_id is required" if tab_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :tab_id => tab_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/tabs/{tab_id}",
    :course_id => course_id,
    :tab_id => tab_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  Tab.new(response)
  

end
update_topic_courses(course_id,topic_id,opts={}) click to toggle source

Update a topic

# File lib/pandarus/v1_api.rb, line 8274
def update_topic_courses(course_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :message,
    :discussion_type,
    :published,
    :delayed_post_at,
    :lock_at,
    :podcast_enabled,
    :podcast_has_student_posts,
    :require_initial_post,
    :assignment,
    :is_announcement,
    :pinned,
    :position_after,
    :group_category_id,
    :allow_rating,
    :only_graders_can_rate,
    :sort_by_rating,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/discussion_topics/{topic_id}",
    :course_id => course_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_topic_groups(group_id,topic_id,opts={}) click to toggle source

Update a topic

# File lib/pandarus/v1_api.rb, line 8328
def update_topic_groups(group_id,topic_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :title,
    :message,
    :discussion_type,
    :published,
    :delayed_post_at,
    :lock_at,
    :podcast_enabled,
    :podcast_has_student_posts,
    :require_initial_post,
    :assignment,
    :is_announcement,
    :pinned,
    :position_after,
    :group_category_id,
    :allow_rating,
    :only_graders_can_rate,
    :sort_by_rating,
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  raise "topic_id is required" if topic_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id,
    :topic_id => topic_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/discussion_topics/{topic_id}",
    :group_id => group_id,
    :topic_id => topic_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:put, path, query_params, form_params, headers)
  response
  

end
update_user_settings(id,opts={}) click to toggle source

Update user settings.

# File lib/pandarus/v1_api.rb, line 25709
def update_user_settings(id,opts={})
  query_param_keys = [
    :manual_mark_as_read,
    :collapse_global_nav

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "id is required" if id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :id => id

  )

  # resource path
  path = path_replace("/v1/users/{id}/settings",
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:get, path, query_params, form_params, headers)
  response
  

end
upload_file(course_id,opts={}) click to toggle source

Upload a file

# File lib/pandarus/v1_api.rb, line 7005
def upload_file(course_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/files",
    :course_id => course_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
upload_file_V1_0(folder_id,opts={}) click to toggle source

Upload a file

# File lib/pandarus/v1_api.rb, line 13090
def upload_file_V1_0(folder_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "folder_id is required" if folder_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :folder_id => folder_id

  )

  # resource path
  path = path_replace("/v1/folders/{folder_id}/files",
    :folder_id => folder_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
upload_file_V1_1(group_id,opts={}) click to toggle source

Upload a file

# File lib/pandarus/v1_api.rb, line 14990
def upload_file_V1_1(group_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "group_id is required" if group_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :group_id => group_id

  )

  # resource path
  path = path_replace("/v1/groups/{group_id}/files",
    :group_id => group_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
upload_file_V1_2(course_id,quiz_id,opts={}) click to toggle source

Upload a file

# File lib/pandarus/v1_api.rb, line 21947
def upload_file_V1_2(course_id,quiz_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :name,
    :on_duplicate,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "quiz_id is required" if quiz_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :quiz_id => quiz_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{quiz_id}/submissions/self/files",
    :course_id => course_id,
    :quiz_id => quiz_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
upload_file_V1_3(course_id,assignment_id,user_id,opts={}) click to toggle source

Upload a file

# File lib/pandarus/v1_api.rb, line 23909
def upload_file_V1_3(course_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{user_id}/comments/files",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
upload_file_V1_4(user_id,opts={}) click to toggle source

Upload a file

# File lib/pandarus/v1_api.rb, line 25534
def upload_file_V1_4(user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/users/{user_id}/files",
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
upload_file_courses(course_id,assignment_id,user_id,opts={}) click to toggle source

Upload a file

# File lib/pandarus/v1_api.rb, line 24281
def upload_file_courses(course_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/assignments/{assignment_id}/submissions/{user_id}/files",
    :course_id => course_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
upload_file_sections(section_id,assignment_id,user_id,opts={}) click to toggle source

Upload a file

# File lib/pandarus/v1_api.rb, line 24321
def upload_file_sections(section_id,assignment_id,user_id,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    

  ]

  # verify existence of params
  raise "section_id is required" if section_id.nil?
  raise "assignment_id is required" if assignment_id.nil?
  raise "user_id is required" if user_id.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id

  )

  # resource path
  path = path_replace("/v1/sections/{section_id}/assignments/{assignment_id}/submissions/{user_id}/files",
    :section_id => section_id,
    :assignment_id => assignment_id,
    :user_id => user_id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  response
  

end
validate_quiz_access_code(course_id,id,access_code,opts={}) click to toggle source

Validate quiz access code

# File lib/pandarus/v1_api.rb, line 22717
def validate_quiz_access_code(course_id,id,access_code,opts={})
  query_param_keys = [
    

  ]

  form_param_keys = [
    :access_code,
    

  ]

  # verify existence of params
  raise "course_id is required" if course_id.nil?
  raise "id is required" if id.nil?
  raise "access_code is required" if access_code.nil?
  # set default values and merge with input
  options = underscored_merge_opts(opts,
    :course_id => course_id,
    :id => id,
    :access_code => access_code

  )

  # resource path
  path = path_replace("/v1/courses/{course_id}/quizzes/{id}/validate_access_code",
    :course_id => course_id,
    :id => id)
  headers = nil
  form_params = select_params(options, form_param_keys)
  query_params = select_query_params(options, query_param_keys)

  response = mixed_request(:post, path, query_params, form_params, headers)
  boolean.new(response)
  

end