def put(self, request, column_id, format=None):
try:
gutils.verify_at_least_one_key_present(
self.data, ['displayName', 'description', 'gradeSystemId'])
gradebook = grutils.get_object_gradebook(self.gm, column_id,
'gradebook_column')
gradebook_column = gradebook.get_gradebook_column(
gutils.clean_id(column_id))
form = gradebook.get_gradebook_column_form_for_update(
gradebook_column.ident)
form = gutils.set_form_basics(form, self.data)
if 'gradeSystemId' in self.data:
form.set_grade_system(
gutils.clean_id(self.data['gradeSystemId']))
gradebook.update_gradebook_column(form)
gradebook_column = gradebook.get_gradebook_column(
gradebook_column.ident)
return gutils.UpdatedResponse(gradebook_column.object_map)
except (PermissionDenied, InvalidArgument, KeyError) as ex:
gutils.handle_exceptions(ex)
except IllegalState as ex:
modified_ex = type(ex)('Entries exist in this gradebook column. ' +
'Cannot change the grade system.')
gutils.handle_exceptions(modified_ex)
def get(self, request, gradebook_id=None, format=None):
try:
if gradebook_id is None:
grade_system_lookup_session = grutils.get_session(
self.gm, 'grade_system', 'lookup')
grade_system_query_session = grutils.get_session(
self.gm, 'grade_system', 'query')
grade_system_lookup_session.use_federated_gradebook_view()
grade_system_query_session.use_federated_gradebook_view()
else:
grade_system_query_session = grade_system_lookup_session = self.gm.get_gradebook(
gutils.clean_id(gradebook_id))
if len(self.data) == 0:
grade_systems = grade_system_lookup_session.get_grade_systems()
else:
allowable_query_terms = ['displayName', 'description']
if any(term in self.data for term in allowable_query_terms):
querier = grade_system_query_session.get_grade_system_query(
)
querier = gutils.config_osid_object_querier(
querier, self.data)
grade_systems = grade_system_query_session.get_grade_systems_by_query(
querier)
else:
grade_systems = grade_system_query_session.get_grade_systems(
)
data = gutils.extract_items(request, grade_systems)
return Response(data)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def get(self, request, item_id, format=None):
try:
bank = autils.get_object_bank(self.am,
item_id,
object_type='item',
bank_id=None)
item = bank.get_item(gutils.clean_id(item_id))
data = gutils.convert_dl_object(item)
gutils.update_links(request, data)
if 'fileIds' in data and bool(data['fileIds']):
data['files'] = item.get_files()
if data['question'] and 'fileIds' in data['question'] and bool(
data['question']['fileIds']):
data['question']['files'] = item.get_question().get_files()
try:
if 'renderable_edxml' in self.data:
data['texts']['edxml'] = item.get_edxml_with_aws_urls()
except AttributeError:
pass
return Response(data)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def get(self, request, gradebook_id, format=None):
try:
gradebook = self.gm.get_gradebook(gutils.clean_id(gradebook_id))
gradebook = gutils.convert_dl_object(gradebook)
gutils.update_links(request, gradebook)
return Response(gradebook)
except (PermissionDenied, InvalidId, NotFound) as ex:
gutils.handle_exceptions(ex)
def get(self, request, bank_id, format=None):
try:
assessment_bank = self.am.get_bank(gutils.clean_id(bank_id))
bank = gutils.convert_dl_object(assessment_bank)
gutils.update_links(request, bank)
return Response(bank)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def get(self, request, format=None):
try:
banks = gutils.extract_items(request, self.lm.objective_banks)
banks['data']['results'] = sorted(
banks['data']['results'],
key=lambda k: k['displayName']['text'].lower())
return Response(banks)
except (PermissionDenied, IntegrityError) as ex:
gutils.handle_exceptions(ex)
def delete(self, request, entry_id, format=None):
try:
gradebook = grutils.get_object_gradebook(self.gm, entry_id,
'grade_entry')
gradebook.delete_grade_entry(gutils.clean_id(entry_id))
return gutils.DeletedResponse()
except (PermissionDenied, IllegalState) as ex:
gutils.handle_exceptions(ex)
def delete(self, request, gradebook_id, format=None):
try:
self.gm.delete_gradebook(gutils.clean_id(gradebook_id))
return gutils.DeletedResponse()
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
except IllegalState as ex:
modified_ex = type(ex)('Gradebook is not empty.')
gutils.handle_exceptions(modified_ex)
def get(self, request, format=None):
"""
List all available gradebooks
"""
try:
gradebooks = self.gm.gradebooks
gradebooks = gutils.extract_items(request, gradebooks)
return Response(gradebooks)
except PermissionDenied as ex:
gutils.handle_exceptions(ex)
def get(self, request, bank_id=None, format=None):
try:
if bank_id is None:
item_lookup_session = autils.get_session(
self.am, 'item', 'lookup')
item_query_session = autils.get_session(
self.am, 'item', 'query')
item_lookup_session.use_federated_bank_view()
item_query_session.use_federated_bank_view()
else:
item_query_session = item_lookup_session = self.am.get_bank(
gutils.clean_id(bank_id))
if (len(self.data) == 0 or
(len(self.data) == 1 and self.data.keys()[0] == 'files')):
items = item_lookup_session.get_items()
else:
allowable_query_terms = [
'maximumDifficulty', 'minimumDifficulty',
'maximumDiscrimination', 'mininumDiscrimination',
'displayName', 'learningObjectiveId', 'description'
]
if any(term in self.data for term in allowable_query_terms):
querier = item_query_session.get_item_query()
querier = gutils.config_osid_object_querier(
querier, self.data)
items = item_query_session.get_items_by_query(querier)
else:
items = item_lookup_session.get_items()
data = gutils.extract_items(request, items)
if 'files' in self.data:
for item in data['data']['results']:
# Without complete authz, not a great way to handle
# this -- ignore ?files on items where user has no permissions.
# Ideally, they wouldn't even have these items in their list...
bank = autils.get_object_bank(self.am,
gutils.clean_id(item['id']),
'item')
try:
dlkit_item = bank.get_item(gutils.clean_id(item['id']))
if 'fileIds' in item:
item['files'] = dlkit_item.get_files()
if item['question'] and 'fileIds' in item['question']:
item['question'][
'files'] = dlkit_item.get_question().get_files(
)
except PermissionDenied:
pass
return Response(data)
except (PermissionDenied, IntegrityError) as ex:
gutils.handle_exceptions(ex)
def delete(self, request, column_id, format=None):
try:
gradebook = grutils.get_object_gradebook(self.gm, column_id,
'gradebook_column')
gradebook.delete_gradebook_column(gutils.clean_id(column_id))
return gutils.DeletedResponse()
except (PermissionDenied) as ex:
gutils.handle_exceptions(ex)
except IllegalState as ex:
modified_ex = type(ex)('Gradebook column is not empty.')
gutils.handle_exceptions(modified_ex)
def get(self, request, entry_id, format=None):
try:
gradebook = grutils.get_object_gradebook(self.gm, entry_id,
'grade_entry')
entry = gradebook.get_grade_entry(gutils.clean_id(entry_id))
entry_map = entry.object_map
gutils.update_links(request, entry_map)
return Response(entry_map)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def delete(self, request, gradesystem_id, format=None):
try:
gradebook = grutils.get_object_gradebook(self.gm, gradesystem_id,
'grade_system')
gradebook.delete_grade_system(gutils.clean_id(gradesystem_id))
return gutils.DeletedResponse()
except (PermissionDenied, InvalidArgument) as ex:
gutils.handle_exceptions(ex)
except IllegalState as ex:
modified_ex = type(ex)('Grade system is being used.')
gutils.handle_exceptions(modified_ex)
def put(self, request, bank_id, format=None):
try:
form = self.am.get_bank_form_for_update(gutils.clean_id(bank_id))
form = gutils.set_form_basics(form, self.data)
updated_bank = self.am.update_bank(form)
bank = gutils.convert_dl_object(updated_bank)
gutils.update_links(request, bank)
return gutils.UpdatedResponse(bank)
except (PermissionDenied, InvalidArgument) as ex:
gutils.handle_exceptions(ex)
def get(self, request, gradesystem_id, format=None):
try:
gradebook = grutils.get_object_gradebook(self.gm, gradesystem_id,
'grade_system')
grade_system = gradebook.get_grade_system(
gutils.clean_id(gradesystem_id))
grade_system_map = grade_system.object_map
gutils.update_links(request, grade_system_map)
return Response(grade_system_map)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def get(self, request, objective_id, format=None):
try:
ols = self.lm._instantiate_session(
method_name='get_objective_lookup_session',
proxy=self.lm._proxy)
objective = ols.get_objective(gutils.clean_id(objective_id))
data = gutils.convert_dl_object(objective)
gutils.update_links(request, data)
return Response(data)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def get(self, request, column_id=None, format=None):
try:
if column_id is None:
entry_lookup_session = grutils.get_session(
self.gm, 'grade_entry', 'lookup')
entry_query_session = grutils.get_session(
self.gm, 'grade_entry', 'query')
entry_lookup_session.use_federated_gradebook_view()
entry_query_session.use_federated_gradebook_view()
else:
entry_query_session = entry_lookup_session = grutils.get_object_gradebook(
self.gm, column_id, 'gradebook_column')
if len(self.data) == 0 and column_id is None:
entries = entry_lookup_session.get_grade_entries()
elif column_id is not None:
if len(self.data) == 0:
entries = entry_lookup_session.get_grade_entries_for_gradebook_column(
gutils.clean_id(column_id))
else:
allowable_query_terms = ['displayName', 'description']
if any(term in self.data
for term in allowable_query_terms):
querier = entry_query_session.get_grade_entry_query()
querier = gutils.config_osid_object_querier(
querier, self.data)
querier.match_gradebook_column_id(
gutils.clean_id(column_id))
entries = entry_query_session.get_grade_entries_by_query(
querier)
else:
entries = entry_lookup_session.get_grade_entries_for_gradebook_column(
gutils.clean_id(column_id))
else:
allowable_query_terms = ['displayName', 'description']
if any(term in self.data for term in allowable_query_terms):
querier = entry_query_session.get_grade_entry_query()
querier = gutils.config_osid_object_querier(
querier, self.data)
entries = entry_query_session.get_grade_entries_by_query(
querier)
else:
entries = entry_lookup_session.get_grade_entries()
data = gutils.extract_items(request, entries)
return Response(data)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def delete(self, request, item_id, format=None):
try:
bank = autils.get_object_bank(self.am,
item_id,
object_type='item',
bank_id=None)
data = bank.delete_item(gutils.clean_id(item_id))
return gutils.DeletedResponse(data)
except PermissionDenied as ex:
gutils.handle_exceptions(ex)
except IllegalState as ex:
gutils.handle_exceptions(
type(ex)('This Item is being used in one or more '
'Assessments. Delink it first, before '
'deleting it.'))
def put(self, request, gradebook_id, format=None):
try:
form = self.gm.get_gradebook_form_for_update(
gutils.clean_id(gradebook_id))
gutils.verify_at_least_one_key_present(
self.data, ['displayName', 'description'])
form = gutils.set_form_basics(form, self.data)
updated_gradebook = self.gm.update_gradebook(form)
updated_gradebook = gutils.convert_dl_object(updated_gradebook)
return gutils.UpdatedResponse(updated_gradebook)
except (PermissionDenied, KeyError, InvalidArgument, NotFound) as ex:
gutils.handle_exceptions(ex)
def post(self, request, format=None):
"""
Create a new assessment bank, if authorized
Create a new group in IS&T Membership service
"""
try:
form = self.am.get_bank_form_for_create([])
form = gutils.set_form_basics(form, self.data)
new_bank = gutils.convert_dl_object(self.am.create_bank(form))
return gutils.CreatedResponse(new_bank)
except (PermissionDenied, InvalidArgument) as ex:
gutils.handle_exceptions(ex)
def post(self, request, gradebook_id=None, format=None):
try:
if gradebook_id is None:
gutils.verify_keys_present(self.data, ['gradebookId'])
gradebook_id = self.data['gradebookId']
gutils.verify_at_least_one_key_present(
self.data, ['displayName', 'description'])
gradebook = self.gm.get_gradebook(gutils.clean_id(gradebook_id))
form = gradebook.get_grade_system_form_for_create([])
form = gutils.set_form_basics(form, self.data)
check_scores = True
if 'basedOnGrades' in self.data:
form.set_based_on_grades(bool(self.data['basedOnGrades']))
if self.data['basedOnGrades']:
check_scores = False
if check_scores:
grutils.check_numeric_score_inputs(self.data)
form.set_highest_numeric_score(float(
self.data['highestScore']))
form.set_lowest_numeric_score(float(self.data['lowestScore']))
form.set_numeric_score_increment(
float(self.data['scoreIncrement']))
grade_system = gradebook.create_grade_system(form)
if not check_scores:
grutils.check_grade_inputs(self.data)
grutils.add_grades_to_grade_system(gradebook, grade_system,
self.data)
grade_system = gradebook.get_grade_system(grade_system.ident)
return gutils.CreatedResponse(grade_system.object_map)
except (PermissionDenied, InvalidArgument, KeyError) as ex:
try:
gradebook.delete_grade_system(grade_system.ident)
except NameError:
pass
gutils.handle_exceptions(ex)
def get(self, request, item_id, format=None):
try:
bank = autils.get_object_bank(self.am, item_id, 'item')
item = bank.get_item(gutils.clean_id(item_id))
filename, olx = item.export_standalone_olx()
response = HttpResponse(content_type="application/tar")
response[
'Content-Disposition'] = 'attachment; filename=%s' % filename
olx.seek(0, os.SEEK_END)
response.write(olx.getvalue())
olx.close()
return response
except (PermissionDenied, InvalidArgument, NotFound) as ex:
gutils.handle_exceptions(ex)
def get(self, request, bank_id=None, format=None):
try:
if bank_id is None:
objectives = []
for bank in self.lm.objective_banks:
objectives += list(bank.get_objectives())
objectives = gutils.extract_items(request, objectives)
else:
bank = self.lm.get_objective_bank(gutils.clean_id(bank_id))
objectives = gutils.extract_items(request,
bank.get_objectives())
objectives['data']['results'] = sorted(
objectives['data']['results'],
key=lambda k: k['displayName']['text'])
return Response(objectives)
except (PermissionDenied, IntegrityError) as ex:
gutils.handle_exceptions(ex)
def get(self, request, item_id, format=None):
try:
bank = autils.get_object_bank(self.am,
item_id,
object_type='item',
bank_id=None)
item = bank.get_item(gutils.clean_id(item_id))
data = {'data': {'data': [], 'count': 0}}
try:
data = gutils.extract_items(request,
item.get_learning_objectives())
except KeyError:
pass
except IllegalState:
# no learning objectives
pass
return Response(data)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def get(self, request, column_id, format=None):
try:
gradebook = grutils.get_object_gradebook(self.gm, column_id,
'gradebook_column')
if gradebook.get_grade_entries_for_gradebook_column(
gutils.clean_id(column_id)).available() > 0:
gradebook_column_summary = gradebook.get_gradebook_column_summary(
gutils.clean_id(column_id))
gradebook_column_summary_map = {
'_links': {
'self': gutils.build_safe_uri(request)
},
'mean':
gradebook_column_summary.get_mean(),
'median':
gradebook_column_summary.get_median(),
'mode':
gradebook_column_summary.get_mode(),
'rootMeanSquared':
gradebook_column_summary.get_rms(),
'standardDeviation':
gradebook_column_summary.get_standard_deviation(),
'sum':
gradebook_column_summary.get_sum()
}
else:
gradebook_column_summary_map = {
'_links': {
'self': gutils.build_safe_uri(request)
},
'mean': 0.0,
'median': 0.0,
'mode': 0.0,
'rootMeanSquared': 0.0,
'standardDeviation': 0.0,
'sum': 0.0
}
return Response(gradebook_column_summary_map)
except (PermissionDenied, NotFound) as ex:
gutils.handle_exceptions(ex)
def post(self, request, gradebook_id=None, format=None):
try:
if gradebook_id is None:
gutils.verify_keys_present(self.data, ['gradebookId'])
gradebook_id = self.data['gradebookId']
gutils.verify_keys_present(self.data, ['gradeSystemId'])
gradebook = self.gm.get_gradebook(gutils.clean_id(gradebook_id))
form = gradebook.get_gradebook_column_form_for_create([])
form = gutils.set_form_basics(form, self.data)
form.set_grade_system(gutils.clean_id(self.data['gradeSystemId']))
column = gradebook.create_gradebook_column(form)
return gutils.CreatedResponse(column.object_map)
except (PermissionDenied, InvalidArgument, KeyError) as ex:
gutils.handle_exceptions(ex)
def get(self, request, format=None):
"""
List all available assessment banks
"""
try:
if len(self.data) == 0:
assessment_banks = self.am.banks
else:
querier = self.am.get_bank_query()
allowable_query_terms = ['displayName', 'description']
if any(term in self.data for term in allowable_query_terms):
querier = gutils.config_osid_object_querier(
querier, self.data)
assessment_banks = self.am.get_banks_by_query(querier)
else:
assessment_banks = self.am.banks
banks = gutils.extract_items(request, assessment_banks)
return Response(banks)
except PermissionDenied as ex:
gutils.handle_exceptions(ex)
def post(self, request, column_id=None, format=None):
try:
if column_id is None:
gutils.verify_keys_present(self.data, ['gradebookColumnId'])
column_id = self.data['gradebookColumnId']
gutils.verify_at_least_one_key_present(
self.data, ['grade', 'score', 'ignoredForCalculations'])
gutils.verify_keys_present(self.data, ['resourceId'])
gradebook = grutils.get_object_gradebook(self.gm, column_id,
'gradebook_column')
column = gradebook.get_gradebook_column(gutils.clean_id(column_id))
grutils.validate_score_and_grades_against_system(
column.get_grade_system(), self.data)
form = gradebook.get_grade_entry_form_for_create(
column.ident, gutils.clean_id(self.data['resourceId']), [])
form = gutils.set_form_basics(form, self.data)
if 'ignoredForCalculations' in self.data:
form.set_ignored_for_calculations(
bool(self.data['ignoredForCalculations']))
if 'grade' in self.data:
form.set_grade(gutils.clean_id(self.data['grade']))
if 'score' in self.data:
form.set_score(float(self.data['score']))
entry = gradebook.create_grade_entry(form)
return gutils.CreatedResponse(entry.object_map)
except (PermissionDenied, InvalidArgument, IllegalState,
KeyError) as ex:
gutils.handle_exceptions(ex)
def post(self, request, format=None):
"""
Create a new bin, if authorized
"""
try:
if 'bankId' not in self.data:
gutils.verify_keys_present(self.data,
['displayName', 'description'])
form = self.gm.get_gradebook_form_for_create([])
finalize_method = self.gm.create_gradebook
else:
gradebook = self.gm.get_gradebook(Id(self.data['bankId']))
form = self.gm.get_gradebook_form_for_update(gradebook.ident)
finalize_method = self.gm.update_gradebook
form = gutils.set_form_basics(form, self.data)
new_gradebook = gutils.convert_dl_object(finalize_method(form))
return gutils.CreatedResponse(new_gradebook)
except (PermissionDenied, InvalidArgument, NotFound, KeyError) as ex:
gutils.handle_exceptions(ex)
def put(self, request, entry_id, format=None):
try:
gutils.verify_at_least_one_key_present(self.data, [
'displayName', 'description', 'grade', 'score',
'ignoredForCalculations'
])
gradebook = grutils.get_object_gradebook(self.gm, entry_id,
'grade_entry')
entry = gradebook.get_grade_entry(gutils.clean_id(entry_id))
grade_system = entry.get_gradebook_column().get_grade_system()
grutils.validate_score_and_grades_against_system(
grade_system, self.data)
form = gradebook.get_grade_entry_form_for_update(entry.ident)
form = gutils.set_form_basics(form, self.data)
if 'grade' in self.data:
form.set_grade(gutils.clean_id(self.data['grade']))
if 'score' in self.data:
form.set_score(float(self.data['score']))
if 'ignoredForCalculations' in self.data:
form.set_ignored_for_calculations(
bool(self.data['ignoredForCalculations']))
gradebook.update_grade_entry(form)
entry = gradebook.get_grade_entry(entry.ident)
return gutils.UpdatedResponse(entry.object_map)
except (PermissionDenied, InvalidArgument, KeyError) as ex:
gutils.handle_exceptions(ex)
