def get_question(self, question_id=None, question_map=None):
if question_id is not None:
question_map = self._get_question_map(
question_id) # Throws NotFound()
real_question_id = Id(question_map['questionId'])
display_elements = question_map['displayElements']
item = self._get_item_lookup_session().get_item(real_question_id)
question = item.get_question()
# Try to set a new display name and label
try:
if len(display_elements) > 0:
new_display_name = [str(e) for e in display_elements]
question.set_display_label('.'.join(new_display_name))
except AttributeError:
pass
# Claim authority over this question:
question._authority = ASSESSMENT_AUTHORITY
# Override Item Id of this question (this is the Id that Questions report)
question._item_id = Id(namespace='assessment.Item',
identifier=str(question_map['_id']),
authority=ASSESSMENT_AUTHORITY)
return question
def __init__(self, osid_object, **kwargs):
super(edXMultiChoiceQuestionRecord, self).__init__(osid_object)
# change my_map
if ('rerandomize' in self.my_osid_object._my_map
and self.my_osid_object._my_map['rerandomize'] == 'always'):
shuffle(self.my_osid_object._my_map['choices'])
# handle deprecated data...this should go away once Luwen re-loads
# her data with newer assessmentsv2/views.py code
try:
am = self.my_osid_object._get_provider_manager('ASSESSMENT',
local=True)
try:
ils = am.get_item_lookup_session_for_bank(
Id(self.my_osid_object._my_map['assignedBankIds'][0]),
proxy=self.my_osid_object._proxy)
except TypeError: # not a proxy manager
ils = am.get_item_lookup_session_for_bank(
Id(self.my_osid_object._my_map['assignedBankIds'][0]))
item = ils.get_item(Id(self.my_osid_object._my_map['itemId']))
if 'rerandomize' in item._my_map and item._my_map[
'rerandomize'] == 'always':
shuffle(self.my_osid_object._my_map['choices'])
except (KeyError, NotFound, IllegalState, AttributeError) as ex:
import logging
logging.info(ex.args[0])
def _init_metadata(self):
"""stub"""
self._start_timestamp_metadata = {
'element_id': Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'start_timestamp'),
'element_label': 'start timestamp',
'instructions': 'enter an integer number of seconds for the start time',
'required': False,
'read_only': False,
'linked': False,
'array': False,
'syntax': 'INTEGER',
'minimum_integer': 0,
'maximum_integer': None,
'integer_set': [],
'default_integer_values': [0]
}
self._end_timestamp_metadata = {
'element_id': Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'end_timestamp'),
'element_label': 'end timestamp',
'instructions': 'enter an integer number of seconds for the end time',
'required': False,
'read_only': False,
'linked': False,
'array': False,
'syntax': 'INTEGER',
'minimum_integer': 0,
'maximum_integer': None,
'integer_set': [],
'default_integer_values': [0]
}
def _init_metadata(self):
from . import mdata_conf
from ..primitives import Id
from ..osid.objects import OsidForm
OsidForm._init_metadata(self)
self._display_name_metadata = {
'element_id':
Id(authority=self._authority,
namespace=self._namespace,
identifier='display_name')
}
self._display_name_metadata.update(mdata_conf.display_name)
self._display_label_metadata = {
'element_id':
Id(authority=self._authority,
namespace=self._namespace,
identifier='description')
}
self._display_label_metadata.update(mdata_conf.display_label)
self._description_metadata = {
'element_id':
Id(authority=self._authority,
namespace=self._namespace,
identifier='description')
}
self._description_metadata.update(mdata_conf.description)
self._domain_metadata = {
'element_id':
Id(authority=self._authority,
namespace=self._namespace,
identifier='description')
}
self._domain_metadata.update(mdata_conf.domain)
def __init__(self, db, collection=None, runtime=None):
if not MONGO_CLIENT.is_mongo_client_set() and runtime is not None:
set_mongo_client(runtime)
db_prefix = ''
try:
db_prefix_param_id = Id('parameter:mongoDBNamePrefix@mongo')
db_prefix = runtime.get_configuration().get_value_by_parameter(
db_prefix_param_id).get_string_value()
except (AttributeError, KeyError, NotFound):
pass
if collection is None:
self._mc = MONGO_CLIENT.mongo_client[db_prefix + db]
else:
self._mc = MONGO_CLIENT.mongo_client[db_prefix + db][collection]
# add the collection index, if available in the configs
try:
mongo_indexes_param_id = Id('parameter:indexes@mongo')
mongo_indexes = runtime.get_configuration(
).get_value_by_parameter(
mongo_indexes_param_id).get_object_value()
namespace = '{0}.{1}'.format(db, collection)
if namespace in mongo_indexes:
for field in mongo_indexes[namespace]:
self._mc.create_index(field)
except (AttributeError, KeyError, NotFound):
pass
def assets(self):
resources = []
try:
rm = self.my_osid_object._get_provider_manager('REPOSITORY')
if self.my_osid_object._proxy is None:
acs = rm.get_asset_composition_session_for_repository(
Id(self.my_osid_object._my_map['assignedRepositoryIds'][0]))
else:
acs = rm.get_asset_composition_session_for_repository(
Id(self.my_osid_object._my_map['assignedRepositoryIds'][0]),
proxy=self.my_osid_object._proxy)
for asset in acs.get_composition_assets(self.my_osid_object.ident):
asset_map = asset.object_map
if 'enclosedObjectId' in asset_map:
enclosed_object = asset.get_enclosed_object()
if isinstance(enclosed_object, Assessment):
am = self.my_osid_object._get_provider_manager('ASSESSMENT')
if self.my_osid_object._proxy is None:
abas = am.get_assessment_basic_authoring_session_for_bank(
Id(enclosed_object.object_map['assignedBankIds'][0]))
else:
abas = am.get_assessment_basic_authoring_session_for_bank(
Id(enclosed_object.object_map['assignedBankIds'][0]),
proxy=self.my_osid_object._proxy)
for item in abas.get_items(enclosed_object.ident):
resources.append(item)
elif isinstance(enclosed_object, Item):
resources.append(enclosed_object)
else:
resources.append(asset)
except NotFound:
# no assets
pass
return resources
def _init_metadata(self):
"""stub"""
super(TextsAnswerFormRecord, self)._init_metadata()
self._min_string_length_metadata = {
'element_id': Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'min-string-length'),
'element_label': 'min string length',
'instructions': 'enter minimum string length',
'required': False,
'read_only': False,
'linked': False,
'array': False,
'default_cardinal_values': [self._min_string_length],
'syntax': 'CARDINAL',
'minimum_cardinal': None,
'maximum_cardinal': None,
'cardinal_set': []
}
self._max_string_length_metadata = {
'element_id': Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'max-string-length'),
'element_label': 'max string length',
'instructions': 'enter maximum string length',
'required': False,
'read_only': False,
'linked': False,
'array': False,
'default_cardinal_values': [self._max_string_length],
'syntax': 'CARDINAL',
'minimum_cardinal': None,
'maximum_cardinal': None,
'cardinal_set': []
}
def _init_metadata(self):
"""stub"""
self._min_string_length = None
self._max_string_length = None
self._confused_learning_objectives_metadata = {
'element_id':
Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'confusedLearningObjectiveIds'),
'element_label':
'Confused Learning Objectives',
'instructions':
'List of IDs',
'required':
False,
'read_only':
False,
'linked':
False,
'array':
False,
'default_list_values': [[]],
'syntax':
'LIST'
}
self._feedback_metadata = {
'element_id':
Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace, 'feedback'),
'element_label':
'Feedback',
'instructions':
'enter a feedback string',
'required':
False,
'read_only':
False,
'linked':
False,
'array':
False,
'default_string_values': [{
'text':
'',
'languageTypeId':
str(DEFAULT_LANGUAGE_TYPE),
'scriptTypeId':
str(DEFAULT_SCRIPT_TYPE),
'formatTypeId':
str(DEFAULT_FORMAT_TYPE),
}],
'syntax':
'STRING',
'minimum_string_length':
self._min_string_length,
'maximum_string_length':
self._max_string_length,
'string_set': []
}
def __init__(self, db, collection=None, runtime=None):
if not JSON_CLIENT.is_json_client_set() and runtime is not None:
set_json_client(runtime)
self._json_impl = 'mongo'
try:
use_filesystem_param_id = Id('parameter:useFilesystem@json')
use_filesystem = runtime.get_configuration().get_value_by_parameter(use_filesystem_param_id).get_boolean_value()
if not use_filesystem:
raise AttributeError()
except (AttributeError, KeyError, NotFound):
pass
else:
self._json_impl = 'filesystem'
if self._impl('filesystem'):
host_path = PROJECT_PATH
try:
host_path_param_id = Id('parameter:dataStorePath@json')
if BOOTLOADER:
host_path = '{0}/{1}'.format(host_path,
runtime.get_configuration().get_value_by_parameter(host_path_param_id).get_string_value())
else:
host_path = runtime.get_configuration().get_value_by_parameter(host_path_param_id).get_string_value()
except (AttributeError, KeyError, NotFound):
pass
if collection is None:
self._cursor = '{}/{}'.format(host_path, db)
else:
self._cursor = '{}/{}/{}'.format(host_path, db, collection)
if not os.path.isdir(self._cursor):
os.makedirs(self._cursor)
else:
# use MongoDB as default
db_prefix = ''
try:
db_prefix_param_id = Id('parameter:mongoDBNamePrefix@json')
db_prefix = runtime.get_configuration().get_value_by_parameter(db_prefix_param_id).get_string_value()
except (AttributeError, KeyError, NotFound):
pass
if collection is None:
self._mc = JSON_CLIENT.json_client[db_prefix + db]
else:
self._mc = JSON_CLIENT.json_client[db_prefix + db][collection]
# add the collection index, if available in the configs
try:
mongo_indexes_param_id = Id('parameter:indexes@json')
mongo_indexes = runtime.get_configuration().get_value_by_parameter(mongo_indexes_param_id).get_object_value()
namespace = '{0}.{1}'.format(db, collection)
if namespace in mongo_indexes:
for field in mongo_indexes[namespace]:
self._mc.create_index(field)
except (AttributeError, KeyError, NotFound):
pass
def _notify_receiver(self, receiver, params, doc):
"""Send notification to the receiver"""
verb = VMAP[doc['op']]
ns = doc['ns']
notification_id = Id(ns + 'Notification:' + str(ObjectId()) + '@' +
params['authority'])
object_id = Id(ns + ':' + str(doc['o']['_id']) + '@' +
params['authority'])
getattr(receiver,
'_'.join([verb, params['obj_name_plural']]))(notification_id,
[object_id])
return notification_id
def get_group_id_to_child(self):
""" At a minimum need a course composition parent and two children to the split test
course composition
|
split_test composition
| |
vertical vertical
And the expected output is a URL-safe (" instead of ") JSON string, of this object
{
0: "i4x://<org>/<course-name-slug>/<child-tag>/<child-name-slug>,
1: "i4x://<org>/<course-name-slug>/<tag>/<child-name-slug>
}
"""
# get the children compositions, then construct
# the escaped-JSON structure for this split_test
group_ids = {}
# also need the course name...so go up the composition tree
course_node = None
found_course = False
rm = self.my_osid_object._get_provider_manager('REPOSITORY')
if self.my_osid_object._proxy is not None:
cqs = rm.get_composition_query_session_for_repository(Id(self.my_osid_object._my_map['assignedRepositoryIds'][0]),
proxy=self.my_osid_object._proxy)
else:
cqs = rm.get_composition_query_session_for_repository(
Id(self.my_osid_object._my_map['assignedRepositoryIds'][0]))
search_node = self.my_osid_object
while not found_course:
querier = cqs.get_composition_query()
cqs.use_unsequestered_composition_view()
querier.match_contained_composition_id(search_node.ident, True)
parents = cqs.get_compositions_by_query(querier)
if parents.available() == 0:
found_course = True
else:
parent = next(parents)
if parent.genus_type.identifier == 'course':
found_course = True
course_node = parent
else:
search_node = parent
if course_node is None:
return ''
else:
for index, child in enumerate(self.my_osid_object.get_children()):
group_ids[index] = 'i4x://{0}/{1}/{2}/{3}'.format(course_node.org.text,
re.sub('[^\w\s-]', '', course_node.display_name.text),
child.genus_type.identifier,
child.url)
return json.dumps(group_ids).replace('"', '"')
def wrapper(self, *args):
valid_item = False
try:
if Id(self.my_osid_object_form._my_map['genusTypeId']).identifier in whitelist:
valid_item = True
except AttributeError:
if Id(self.my_osid_object._my_map['genusTypeId']).identifier in whitelist:
valid_item = True
finally:
if valid_item:
return func(self, *args)
else:
raise IllegalState('Method not allowed for this object.')
def _init_metadata(self):
"""stub"""
super(EdXCompositionFormRecord, self)._init_metadata()
TextsFormRecord._init_metadata(self) # because the OsidForm breaks the MRO chain for super, in TemporalFormRecord
ProvenanceFormRecord._init_metadata(self) # because the OsidForm breaks the MRO chain for super, in TemporalFormRecord
self._visible_to_students_metadata = {
'element_id': Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'visible_to_students'),
'element_label': 'Visible to students',
'instructions': 'enter a boolean value',
'required': False,
'read_only': False,
'linked': False,
'array': False,
'default_boolean_values': [True],
'syntax': 'BOOLEAN'
}
self._draft_metadata = {
'element_id': Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'draft'),
'element_label': 'Draft',
'instructions': 'enter a boolean value',
'required': False,
'read_only': False,
'linked': False,
'array': False,
'default_boolean_values': [False],
'syntax': 'BOOLEAN'
}
# ideally this would be type LIST?
self._learning_objective_ids_metadata = {
'element_id': Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'learning_objectives'),
'element_label': 'learning_objectives',
'instructions': 'enter a list of strings',
'required': False,
'read_only': False,
'linked': False,
'array': True,
'default_string_values': [[]],
'syntax': 'STRING',
'minimum_string_length': self._min_string_length,
'maximum_string_length': self._max_string_length,
'string_set': []
}
def _init_metadata(self):
ProvenanceFormRecord._init_metadata(self)
TextsFormRecord._init_metadata(self)
super(edXAssetFormRecord, self)._init_metadata()
# ideally this would be type LIST?
self._learning_objective_ids_metadata = {
'element_id':
Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace, 'learning_objectives'),
'element_label':
'learning_objectives',
'instructions':
'enter a list of strings',
'required':
False,
'read_only':
False,
'linked':
False,
'array':
False,
'default_string_values': [[]],
'syntax':
'STRING',
'minimum_string_length':
self._min_string_length,
'maximum_string_length':
self._max_string_length,
'string_set': []
}
def create_first_assessment_section(assessment_id, runtime, proxy, bank_id):
assessment_admin_session, part_admin_session, rule_admin_session = get_admin_sessions(
runtime, proxy, bank_id)
mgr = get_provider_manager('ASSESSMENT',
runtime=runtime,
proxy=proxy,
local=True)
assessment_lookup_session = mgr.get_assessment_lookup_session(proxy=proxy)
assessment_lookup_session.use_federated_bank_view()
assessment = assessment_lookup_session.get_assessment(assessment_id)
part_form = part_admin_session.get_assessment_part_form_for_create_for_assessment(
assessment_id, [SIMPLE_SEQUENCE_RECORD_TYPE])
part_form.set_display_name(assessment.get_display_name().get_text() +
' First Part')
part_form.set_sequestered(
False
) # Any Part of an Assessment must be a Section (i.e. non sequestered)
# part_form.set_weight(100) # Uncomment this line when set_weight is implemented
# Should we set allocated time?
part_id = part_admin_session.create_assessment_part_for_assessment(
part_form).get_id()
if assessment._supports_simple_sequencing():
child_ids = list(assessment.get_child_ids())
child_ids.insert(0, str(part_id))
update_form = assessment_admin_session.get_assessment_form_for_update(
assessment.get_id())
update_form.set_children([Id(i) for i in child_ids])
assessment_admin_session.update_assessment(update_form)
else:
rule_form = rule_admin_session.get_sequence_rule_form_for_create(
assessment.get_id(), part_id, [])
rule_form.set_display_name('First Part Rule')
rule_admin_session.create_sequence_rule(rule_form)
return part_id
def get_choices_file_urls_map(self):
"""stub"""
file_urls_map = []
for choice in self.get_choices():
choice = dict(choice)
small_asset_content = self._get_asset_content(
Id(choice['assetId']), OV_SET_SMALL_ASSET_CONTENT_TYPE)
choice['smallOrthoViewSet'] = small_asset_content.get_url()
small_asset_content = self._get_asset_content(
Id(choice['assetId']), OV_SET_LARGE_ASSET_CONTENT_TYPE)
choice['largeOrthoViewSet'] = small_asset_content.get_url()
del choice['assetId']
file_urls_map.append(choice)
return file_urls_map
def get_choices_files_map(self):
"""stub"""
files_map = []
for choice in self.get_choices():
choice = dict(choice)
choice['smallOrthoViewSet'] = base64.b64encode(
self._get_asset_content(Id(choice['assetId']),
OV_SET_SMALL_ASSET_CONTENT_TYPE
).get_data().read())
choice['largeOrthoViewSet'] = base64.b64encode(
self._get_asset_content(Id(choice['assetId']),
OV_SET_LARGE_ASSET_CONTENT_TYPE
).get_data().read())
del choice['assetId']
files_map.append(choice)
return files_map
def add_user_authz_to_settings(role,
username,
catalog_id=None,
authority='MIT-ODL'):
from .testing import is_string
if is_string(catalog_id):
catalog_id = Id(catalog_id)
agent = create_agent_id(username, authority=authority)
if catalog_id is None:
qualifiers = ('ROOT', 24 * '0')
catalog_id = create_qualifier_id(24 * '0', 'authorization.Vault')
else:
qualifiers = (catalog_id, )
# first, add the base authorizations to the user for the catalog_id and ROOT / '0' * 24
req = get_super_authz_user_request()
vault = get_vault(req)
create_base_authorizations(vault, agent, qualifiers=qualifiers)
# then, depending on role, add additional functions
if role == 'instructor':
authorization_iterator(vault, agent, qualifiers, INSTRUCTOR_FUNCTIONS)
elif role == 'student':
authorization_iterator(vault, agent, qualifiers, STUDENT_FUNCTIONS)
def comment_class_fixture(request):
request.cls.service_config = request.param
request.cls.svc_mgr = Runtime().get_service_manager(
'COMMENTING',
proxy=PROXY,
implementation=request.cls.service_config)
if not is_never_authz(request.cls.service_config):
create_form = request.cls.svc_mgr.get_book_form_for_create([])
create_form.display_name = 'Test catalog'
create_form.description = 'Test catalog description'
request.cls.catalog = request.cls.svc_mgr.create_book(create_form)
form = request.cls.catalog.get_comment_form_for_create(
Id('resource.Resource%3A1%40ODL.MIT.EDU'),
[])
form.display_name = 'Test object'
request.cls.object = request.cls.catalog.create_comment(form)
def class_tear_down():
if not is_never_authz(request.cls.service_config):
for obj in request.cls.catalog.get_comments():
request.cls.catalog.delete_comment(obj.ident)
request.cls.svc_mgr.delete_book(request.cls.catalog.ident)
request.addfinalizer(class_tear_down)
def _init_metadata(self):
"""stub"""
super(MultiLanguageMultipleChoiceQuestionFormRecord,
self)._init_metadata()
self._choices_metadata = {
'element_id':
Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace, 'choices'),
'element_label':
'choices',
'instructions':
'Enter as many text choices as you wish',
'required':
True,
'read_only':
False,
'linked':
False,
'array':
True,
'default_object_values': [[]],
'syntax':
'OBJECT',
'object_set': []
}
def test_can_create_id_with_kwargs(self):
result = Id(authority='AUTHORITY',
namespace='package.Object',
identifier='identifier')
assert result._authority == 'AUTHORITY'
assert result._identifier == 'identifier'
assert result._namespace == 'package.Object'
def get_id(self):
"""override get_id to generate our "magic" id that encodes scaffolding information"""
waypoint_index = 0
if 'waypointIndex' in self.my_osid_object._my_map:
waypoint_index = self.my_osid_object._my_map['waypointIndex']
# NOTE that the order of the dict **must** match the order in generate_children()
# when creating the child_part_id
# 1) level
# 2) objective_ids
# 3) parent_id
# 4) waypoint_index
magic_identifier = OrderedDict({
'level':
self._level,
'objective_ids':
self.my_osid_object._my_map['learningObjectiveIds'],
})
if self._magic_parent_id is not None:
magic_identifier['parent_id'] = str(self._magic_parent_id)
magic_identifier['waypoint_index'] = waypoint_index
identifier = quote('{0}?{1}'.format(
str(self.my_osid_object._my_map['_id']),
json.dumps(magic_identifier)))
return Id(namespace='assessment_authoring.AssessmentPart',
identifier=identifier,
authority=MAGIC_PART_AUTHORITY)
def get_assessment_part(self, assessment_part_id):
authority = assessment_part_id.get_authority()
if assessment_part_id not in self._magic_parts:
if authority == MAGIC_PART_AUTHORITY:
magic_identifier = unquote(assessment_part_id.identifier)
orig_identifier = magic_identifier.split('?')[0]
assessment_part = super(
MagicAssessmentPartLookupSession,
self).get_assessment_part(assessment_part_id=Id(
authority=self._catalog.ident.authority,
namespace=assessment_part_id.get_identifier_namespace(
),
identifier=orig_identifier))
# should a magic assessment part's parent be the original part?
# Or that original part's parent?
assessment_part.initialize(assessment_part_id.identifier,
self._my_assessment_section)
else:
assessment_part = super(
MagicAssessmentPartLookupSession,
self).get_assessment_part(assessment_part_id)
self._magic_parts[assessment_part_id] = assessment_part
return assessment_part
else:
return self._magic_parts[assessment_part_id]
def _init_metadata(self):
"""stub"""
DecimalValuesFormRecord._init_metadata(self)
IntegerValuesFormRecord._init_metadata(self)
TextAnswerFormRecord._init_metadata(self)
super(MultiLanguageCalculationInteractionFeedbackAndFilesAnswerFormRecord, self)._init_metadata()
self._tolerance_mode_metadata = {
'element_id': Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace,
'tolerance_mode'),
'element_label': 'tolerance_mode',
'instructions': 'enter the tolerance mode',
'required': True,
'read_only': False,
'linked': False,
'array': False,
'default_string_values': [{
'text': '',
'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
'formatTypeId': str(DEFAULT_FORMAT_TYPE),
}],
'syntax': 'STRING',
'minimum_string_length': 0,
'maximum_string_length': 1024,
'string_set': []
}
def get_item(self, item_id):
""" see if this is a magic item id (i.e. questionId).
If so, grab the item and set the params.
If not, just pass through to the original Mongo ItemLookupSession
:param item_id:
:return:
"""
authority = item_id.authority
mgr = self._get_provider_manager('ASSESSMENT', local=True)
if self._proxy is not None:
ils = mgr.get_item_lookup_session(proxy=self._proxy)
else:
ils = mgr.get_item_lookup_session()
ils.use_federated_bank_view()
if authority == MAGIC_AUTHORITY:
magic_identifier = unquote(item_id.identifier)
params = json.loads(magic_identifier.split('?')[-1])
orig_identifier = magic_identifier.split('?')[0]
original_item_id = Id(
namespace=item_id.namespace,
authority=self._catalog.ident.authority,
identifier=orig_identifier
)
orig_item = ils.get_item(original_item_id)
orig_item.set_params(params)
return orig_item
else:
return ils.get_item(item_id)
def authorization_class_fixture(request):
request.cls.service_config = request.param
request.cls.authorization_list = list()
request.cls.authorization_ids = list()
request.cls.svc_mgr = Runtime().get_service_manager(
'AUTHORIZATION',
proxy=PROXY,
implementation=request.cls.service_config)
if not is_never_authz(request.cls.service_config):
create_form = request.cls.svc_mgr.get_vault_form_for_create([])
create_form.display_name = 'Test Vault'
create_form.description = 'Test Vault for AuthorizationQuerySession tests'
request.cls.catalog = request.cls.svc_mgr.create_vault(create_form)
create_form = request.cls.catalog.get_authorization_form_for_create_for_agent(
AGENT_ID, LOOKUP_RESOURCE_FUNCTION_ID,
Id(
**{
'identifier': str('foo'),
'namespace': 'resource.Resource',
'authority': 'ODL.MIT.EDU'
}), [])
create_form.display_name = 'Test Authorization'
create_form.description = (
'Test Authorization for Authorization tests')
obj = request.cls.catalog.create_authorization(create_form)
request.cls.object = obj
def class_tear_down():
if not is_never_authz(request.cls.service_config):
for catalog in request.cls.svc_mgr.get_vaults():
for obj in catalog.get_authorizations():
catalog.delete_authorization(obj.ident)
request.cls.svc_mgr.delete_vault(catalog.ident)
request.addfinalizer(class_tear_down)
def _set_authority(self, runtime):
try:
authority_param_id = Id('parameter:authority@mongo')
self._authority = runtime.get_configuration(
).get_value_by_parameter(authority_param_id).get_string_value()
except (AttributeError, KeyError, errors.NotFound):
self._authority = 'GSTUDIO'
def get_id(self):
"""Gets the Id associated with this instance of this OSID object.
Persisting any reference to this object is done by persisting
the Id returned from this method. The Id returned may be
different than the Id used to query this object. In this case,
the new Id should be preferred over the old one for future
queries.
return: (osid.id.Id) - the ``Id``
*compliance: mandatory -- This method must be implemented.*
*implementation notes*: The ``Id`` is intended to be constant
and persistent. A consumer may at any time persist the ``Id``
for retrieval at any future time. Ideally, the Id should
consistently resolve into the designated object and not be
reused. In cases where objects are deactivated after a certain
lifetime the provider should endeavor not to obliterate the
object or its ``Id`` but instead should update the properties of
the object including the deactiavted status and the elimination
of any unwanted pieces of data. As such, there is no means for
updating an ``Id`` and providers should consider carefully the
identification scheme to implement. ``Id`` assignments for
objects are strictly in the realm of the provider and any errors
should be fixed directly with the backend supporting system.
Once an Id has been assigned in a production service it should
be honored such that it may be necessary for the backend system
to support Id aliasing to redirect the lookup to the current
``Id``. Use of an Id OSID may be helpful to accomplish this task
in a modular manner.
"""
identifier = 'None' # re-implement to get real identifier for object
return Id(identifier=str(self._gstudio_node['_id']),
namespace=self._namespace,
authority=self._authority)
def _init_metadata(self):
"""stub"""
self._rerandomize_metadata = {
'element_id':
Id(self.my_osid_object_form._authority,
self.my_osid_object_form._namespace, 'rerandomize'),
'element_label':
'Randomize',
'instructions':
'How to rerandomize the parameters',
'required':
False,
'read_only':
False,
'linked':
False,
'array':
False,
'default_object_values': ['never'],
'syntax':
'STRING',
'minimum_string_length':
None,
'maximum_string_length':
None,
'string_set': []
}
super(edXMultiChoiceQuestionFormRecord, self)._init_metadata()
def get_item_ids_for_assessment_part(self, assessment_part_id):
"""convenience method returns item ids associated with an assessment_part_id"""
item_ids = []
for question_map in self._my_map['questions']:
if question_map['assessmentPartId'] == str(assessment_part_id):
item_ids.append(Id(question_map['itemId']))
return item_ids
