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)