def test_InitUnpack(self):
obj = {'id': '016699c6-d600-48a7-96ab-86187498f16f', 'actor': {'name': 'test'}, 'verb': {'id': 'test'},
'object': {'object_type': 'Agent', 'name': 'test'}, 'authority': {'name': 'test'},
'context': {'registration': '016699c6-d600-48a7-96ab-86187498f16f'},
'attachments': [{'usage_type': 'test'}]}
statement = Statement(**obj)
self.assertEqual(statement.id, uuid.UUID('016699c6-d600-48a7-96ab-86187498f16f'))
self.agentVerificationHelper(statement.actor)
self.verbVerificationHelper(statement.verb)
self.agentVerificationHelper(statement.object)
self.agentVerificationHelper(statement.authority)
self.contextVerificationHelper(statement.context)
for k in statement.attachments:
self.attachmentVerificationHelper(k)
def sendstatement_session_started(self):
aname = 'sysadmin'
actor = Agent(
name=aname,
mbox='mailto:' + aname + '@iltserver.com',
)
verb = Verb(
id='http://activitystrea.ms/schema/1.0/start',
display=LanguageMap({'en-US': 'started'}),
)
statement = Statement(actor=actor,
verb=verb,
object=self._session_object)
self._send_to_LRS(statement)
def sendstatement_sync_all_to_instructor(self, conn):
# the object of this statement is the presentation, in the context of session
verb = Verb(
id='http://adlnet.gov/expapi/verbs/interacted',
display=LanguageMap({'en-US': 'interacted'}),
)
result_obj = Result(extensions=Extensions({
'https://iltserver.com/extensions/sync-all-to-instructor':
'request'
}))
statement = Statement(actor=conn._actor,
verb=verb,
object=self._presentation_object,
result=result_obj)
self._send_to_LRS(statement)
def test_ToJSON(self):
statement = Statement(
**{'id': '016699c6-d600-48a7-96ab-86187498f16f', 'actor': {'name': 'test'}, 'verb': {'id': 'test'},
'object': {'object_type': 'Agent', 'name': 'test'}, 'authority': {'name': 'test'},
'context': {'registration': '016699c6-d600-48a7-96ab-86187498f16f'},
'attachments': [{'usage_type': 'test'}]})
self.assertEqual(json.loads(statement.to_json()),
json.loads('{"verb": {"id": "test"}, '
'"attachments": [{"usageType": "test"}], '
'"object": {"name": "test", "objectType": "Agent"}, '
'"actor": {"name": "test", "objectType": "Agent"}, '
'"version": "1.0.3", '
'"authority": {"name": "test", "objectType": "Agent"}, '
'"context": {"registration": "016699c6-d600-48a7-96ab-86187498f16f"}, '
'"id": "016699c6-d600-48a7-96ab-86187498f16f"}'))
def test_more_statements(self):
s1 = Statement(actor=self.agent,
verb=self.verb,
object=self.parent,
result=self.result,
id=str(uuid.uuid4()))
self.lrs.save_statement(s1)
s2 = Statement(actor=self.agent,
verb=self.verb,
object=self.parent,
result=self.result,
id=str(uuid.uuid4()))
self.lrs.save_statement(s2)
s3 = Statement(actor=self.agent,
verb=self.verb,
object=self.parent,
result=self.result,
id=str(uuid.uuid4()))
self.lrs.save_statement(s3)
query = {
"agent": self.agent,
"verb": self.verb,
"activity": self.parent,
"related_activities": True,
"related_agents": True,
"format": "ids",
"limit": 2
}
query_resp = self.lrs.query_statements(query)
self.assertIsInstance(query_resp, LRSResponse)
self.assertTrue(query_resp.success)
self.assertIsNotNone(query_resp.content.more)
response = self.lrs.more_statements(query_resp.content)
self.assertIsInstance(response, LRSResponse)
self.assertTrue(response.success)
self.assertIsInstance(response.content, StatementsResult)
def test_retrieve_statement(self):
id_str = str(uuid.uuid4())
statement = Statement(actor=self.agent,
verb=self.verb,
object=self.activity,
context=self.context,
result=self.result,
id=id_str,
version=Version.latest,
timestamp=utc.localize(datetime.utcnow()))
save_resp = self.lrs.save_statement(statement)
self.assertTrue(save_resp.success)
response = self.lrs.retrieve_statement(save_resp.content.id)
self.assertIsInstance(response, LRSResponse)
self.assertTrue(response.success)
self._vars_verifier(response.content, statement,
['_authority', '_stored'])
def create_statement(arbtt_csv_entry):
"""Creates a Tincan statement from arbtt csv input"""
arbtt_record = ArbttRecord(arbtt_csv_entry)
app = arbtt_record.application
duration = arbtt_record.duration
# XXX: Look for a cleaner way to get user details
user = os.environ['LOGNAME']
email_address = "*****@*****.**" % (user, )
actor = Agent(
name=user,
mbox='mailto:' + email_address,
)
verb = Verb(
id='http://adlnet.gov/expapi/verbs/interacted',
display=LanguageMap({'en-US': 'interacted'}),
)
# Get activity from config or set the activity as 'unknown'
activity_from_map = activity_map.get(app, "unknown")
object = Activity(
id=os.path.join(lrs['activities_uri'], activity_from_map),
definition=ActivityDefinition(
name=LanguageMap({'en-US': activity_from_map}),
extensions=Extensions(
{'http://id.tincanapi.com/extension/duration': duration}, ),
),
)
context = Context(platform=app)
# Construct the statement
return Statement(
actor=actor,
verb=verb,
object=object,
context=context,
)
def _send_lrs_statement(cls, statement_json):
if not cls.enabled:
return
# should only be called by delayed task send_lrs_statement
lrs_settings = {
'version': cls._version,
'endpoint': current_app.config.get('LRS_STATEMENT_ENDPOINT')
}
if current_app.config.get('LRS_AUTH'):
lrs_settings['auth'] = current_app.config.get('LRS_AUTH')
else:
lrs_settings['username'] = current_app.config.get('LRS_USERNAME')
lrs_settings['password'] = current_app.config.get('LRS_PASSWORD')
statement = Statement(statement_json)
# check statement.result.response, object.definition.name, object.definition.description
if statement.result and statement.result.response:
statement.result.response = cls._trim_text_to_size(
statement.result.response)
if statement.object and statement.object.definition and statement.object.definition.name:
statement.object.definition.name['en-US'] = cls._trim_text_to_size(
statement.object.definition.name['en-US'])
if statement.object and statement.object.definition and statement.object.definition.description:
statement.object.definition.description[
'en-US'] = cls._trim_text_to_size(
statement.object.definition.description['en-US'])
lrs = RemoteLRS(**lrs_settings)
lrs_response = lrs.save_statement(statement)
if not lrs_response.success:
current_app.logger.error("xAPI Failed with: " +
str(lrs_response.data))
current_app.logger.error("xAPI Request Body: " +
lrs_response.request.content)
def build_statement(
user: AbstractUser,
verb: Verb,
obj: Activity,
context: Context,
statement_id: Optional[uuid.UUID] = None,
) -> Optional[Statement]:
"""Build a XAPI Statement based on the current context"""
timestamp = timezone.now().isoformat()
actor = _get_actor_from_user(user)
if statement_id is None:
statement_id = uuid.uuid4()
if actor is None:
logger.warning("Unable to get an XAPI actor definition for user %s",
user.id)
return None
return Statement(
actor=actor,
context=context,
id=statement_id,
object=obj,
timestamp=timestamp,
verb=verb,
)
def test_ExceptionInvalidUUID(self):
with self.assertRaises(ValueError):
Statement(id='badtest')
obj = ACTIVITY_ROUTES[eventname](row['objecttable'],
row['objectid'],
row['contextinstanceid'])
# Context can be built off the object
row['object'] = obj.TYPE_EN
context = obj.getContext(row)
# Timestamp
timestamp = datetime.fromtimestamp(
row['timecreated']).strftime('%Y-%m-%dT%H:%M:%S') + config.TIMEZONE
# Create a statement of information
statement = Statement(actor=actor,
verb=obj.getVerb(),
result=obj.getResult(),
object=obj.getObject(),
context=context,
timestamp=timestamp)
# Commit the statement
response = lrs.save_statement(statement)
if not response.success:
# TODO : Format proper error here
responseObject = json.loads(response.data)
logging.error(
"Failed to insert statement for logID: '%s' for eventname = '%s'"
% (row['id'], row['eventname']))
print statement.to_json()
print str(responseObject['message'][0])
sys.exit(5)
def test_ToJSONEmpty(self):
statement = Statement()
self.assertEqual(json.loads(statement.to_json()), json.loads('{"version": "1.0.3"}'))
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST, request.FILES)
if form.is_valid():
data = form.cleaned_data
project = get_object_or_404(Project, id=data['project'])
user = data['user']
timezone = pytz.timezone("Europe/Rome")
actor = Agent(
name=user.get_display_name(),
mbox='mailto:%s' % user.email,
)
project_id = get_object_id(request, project)
activity_type = xapi_activities['assessment']['type']
object_language = 'it'
verb = Verb(
id=xapi_verbs['completed']['id'],
display=LanguageMap(**xapi_verbs['completed']['display']),
)
file = request.FILES['file']
filename = file.name
extension = filename.split(".")[-1]
content = file.read()
records = pyexcel.get_records(file_type=extension,
file_content=content)
name_dict = records[0]
keys = name_dict.keys()
rows = []
for record in records:
date_time = record['Ora']
lesson = record['Lezione']
course = record['Corso']
activity = record['Attività']
duration_seconds = record['Durata (Secondi)']
response_seconds = record['Tempo medio di risposta (Secondi)']
score_percent = record['Punteggio (%)']
questions = record['Domande con risposta']
correct_answers = record['Risposte corrette']
timestamp = datetime.strptime(date_time, "%d/%m/%Y %H.%M")
timestamp = timezone.localize(timestamp)
object_name = 'EarMaster: {}'.format(activity)
object_description = 'Esercizio di {} in lezione EarMaster "{}"'.format(
activity, lesson)
activity_definition = ActivityDefinition(
name=LanguageMap(**{object_language: object_name}),
description=object_description
and LanguageMap(**{object_language: object_description})
or None,
type=activity_type,
)
course_id = '{}{}'.format(project_id, slugify(course))
lesson_id = '{}/{}'.format(course_id, slugify(lesson))
object = Activity(
objectType='Activity',
id=lesson_id,
definition=activity_definition,
)
parent = {
'objectType': 'Activity',
'id': course_id,
'definition': {
'type': xapi_activities['course']['type'],
'name': {
'it': course
}
}
}
grouping = {
'objectType': 'Activity',
'id': project_id,
'definition': {
'type':
xapi_activities['project']['type'],
'name':
LanguageMap(**{get_language(project): project.name})
}
}
context = {
'platform': 'EarMaster',
'context_activities': {
'parent': parent,
'grouping': grouping
}
}
context = Context(**context)
score_scaled = float(score_percent.replace('%', '')) / 100
score_max = questions
score_raw = correct_answers
score = {
'min': 0,
'max': score_max,
'raw': score_raw,
'scaled': score_scaled
}
score = Score(**score)
result = {'duration': duration_seconds, 'score': score}
result = Result(**result)
statement = Statement(actor=actor,
verb=verb,
object=object,
context=context,
result=result,
timestamp=timestamp)
result = send_statement(statement)
return HttpResponseRedirect('/project/%s/' % project.slug)
return render(request, self.template_name,
{'earmaster_import_results_form': form})
def generate_from_params(cls, user, params):
statement = Statement(params)
return cls._add_default(user, statement)
print "constructing the Context..."
context = Context(
registration=uuid.uuid4(),
instructor=Agent(
name='Lord TinCan',
mbox='mailto:[email protected]',
),
# language='en-US',
)
print "...done"
# construct the actual statement
print "constructing the Statement..."
statement = Statement(
actor=actor,
verb=verb,
object=object,
context=context,
)
print "...done"
# save our statement to the remote_lrs and store the response in 'response'
print "saving the Statement..."
response = lrs.save_statement(statement)
if not response:
raise ValueError("statement failed to save")
print "...done"
# retrieve our statement from the remote_lrs using the id returned in the response
print "Now, retrieving statement..."
response = lrs.retrieve_statement(response.content.id)
def generate_from_params(cls, user, params, course=None):
statement = Statement(params)
if course:
XAPIContext._add_sis_data(statement.context, course)
return cls._add_default(user, statement)
def put_statement(request, user, verb, object, target, language=XAPI_LANGUAGE):
# construct an LRS
lrs = RemoteLRS(
version=settings.LRS_VERSION,
endpoint=settings.LRS_ENDPOINT,
auth=settings.LRS_AUTH,
)
# construct the actor of the statement
# IMPORTANT - account is OK but cannot coexist with mbox or other way of uniquely identifying the actor
try:
actor = Agent(
name=user.get_display_name(),
mbox='mailto:%s' % user.email,
# account=AgentAccount(name=str(user.pk), home_page='https://www.commonspaces.eu')
)
except:
return False
# construct the verb of the statement
verb = XAPI_VERB_ALIASES.get(verb,
verb) # for compatibility with CommonSpaces
verb = Verb(
id=xapi_verbs[verb]['id'],
display=LanguageMap(**xapi_verbs[verb]['display']),
)
action = object.__class__.__name__
action = XAPI_ACTIVITY_ALIASES.get(
action, action) # for compatibility with CommonSpaces
activity_type = xapi_activities[action]['type']
object_id = get_object_id(request,
object) # 190307 GT: defined get_object_id
object_name = get_name(object) # 190307 GT: defined get_name
object_description = get_description(object)
object_language = get_language(object)
activity_definition = ActivityDefinition(
name=LanguageMap(**{object_language: object_name}),
description=object_description
and LanguageMap(**{object_language: object_description}) or None,
type=activity_type,
)
# construct the object of the statement
object = Activity(
id=object_id,
definition=activity_definition,
)
context = {'platform': XAPI_PLATFORM, 'language': get_current_language()}
""" 190308 GT: would produce the exception "Object of type 'UUID' is not JSON serializable" in getting the response
if request:
context['registration'] = str(get_registration(request))
"""
if target:
target_type = target.__class__.__name__
context_activities = {}
if target_type in ['Folder', 'Forum', 'LearningPath']:
context_activities['parent'] = {
'objectType': 'Activity',
'id': get_object_id(request, target),
'definition': {
'type':
xapi_activities[XAPI_ACTIVITY_ALIASES.get(
target_type, target_type)]['type'],
'name': {
'en': get_name(target)
}
}
}
if target_type == 'Folder':
project = target.get_project()
if project:
context_activities['grouping'] = get_context_grouping(
request, project)
elif target_type == 'Forum':
# project = target.forum_get_project()
project = target.get_project()
if project:
context_activities['grouping'] = get_context_grouping(
request, project)
elif target_type == 'LearningPath':
if target.project:
context_activities['grouping'] = get_context_grouping(
request, target.project)
elif target_type == 'Project':
context_activities['grouping'] = get_context_grouping(
request, target)
if context_activities:
context['context_activities'] = context_activities
context = Context(**context)
# construct the actual statement
statement = Statement(
actor=actor,
verb=verb,
object=object,
context=context,
)
return send_statement(statement)
def sendStatement(self, reqData):
#load requested data for statement generation
data = json.loads(reqData)
# create RemoteLRS endpoint
lrs = self.LRS
# generate statement
# 1. actor
actor = Agent(
name=data["name"],
mbox='mailto:' + data["name"] + '@id.lrs',
)
# 2. verb
verb = Verb(
id=self.verbs.get(data["verb"]),
display=LanguageMap({'en-US': data["verb"]}),
)
# 3. object
obj = Activity(
id=self.objects.get(data["activity"]),
definition=ActivityDefinition(
name=LanguageMap({'en-US': data["activityid"]})
)
)
# 4. context
context = Context(
extensions=Extensions({
self.extensions.get("difficulty"): data["difficulty"],
self.extensions.get("interaction"): data["interaction"],
self.extensions.get("topic"): data["topic"]
})
)
# 5. result
result = Result(
score=Score(
raw=data["score"]
),
success=data["success"]
)
# build statement
statement = Statement(
actor=actor,
verb=verb,
object=obj,
context=context,
result=result
)
# save statement
response = lrs.save_statement(statement)
# check response
if not response:
raise ValueError("statement failed to save")
return str(True)
def test_ToJSONEmpty(self):
statement = Statement()
self.assertEqual(statement.to_json(), '{"version": "1.0.1"}')
def test_ToJSONEmpty(self):
statement = Statement()
self.assertEqual(statement.to_json(), '{"version": "' + lrs_properties.version + '"}')
def post(self, request, *args, **kwargs):
result = None
project_title = request.GET.get('ca_name', None)
project_url = request.GET.get('ca_id', None)
form = self.form_class(request.POST)
date_time = request.POST.get('timestamp', '')
print('date_time:', date_time)
if form.is_valid():
# <process form cleaned data>
data = form.cleaned_data
if form.data.get('send', ''):
actor = Agent(name=data['actor_name'],
mbox='mailto:{}'.format(data['actor_email']))
verb_id = data['verb_id']
verb = Verb(
id=verb_id,
display=LanguageMap(
**xapi_verbs_by_id[verb_id]['display']),
)
object_language = data['object_language']
activity_definition = ActivityDefinition(
name=LanguageMap(**{object_language: data['object_name']}),
type=data['activity_type'],
)
if data['object_description']:
activity_definition.description = LanguageMap(
**{object_language: data['object_description']})
object = Activity(
id=make_uri(data['object_id']),
definition=activity_definition,
)
context = {'platform': data['platform']}
if data['context_object_name'] and data['context_object_id']:
context_activity_definition = ActivityDefinition(
name=LanguageMap(
**{object_language: data['context_object_name']}),
type=data['context_activity_type'],
)
context_activity_object = Activity(
id=make_uri(data['context_object_id']),
definition=context_activity_definition,
)
context_activities = {
data['context_activity_relationship']:
context_activity_object
}
context['context_activities'] = context_activities
"""
authority = Agent(
name=data['authority_name'],
mbox='mailto:{}'.format(data['authority_email'])
)
"""
timestamp = data['timestamp']
print('timestamp 1:', timestamp)
"""
timestamp = datetime.strptime(date_time, "%d/%m/%Y %H:%M")
print('timestamp 2:', timestamp)
"""
statement = Statement(actor=actor,
verb=verb,
object=object,
context=context,
timestamp=timestamp)
result = send_statement(statement)
recipe_ids = request.POST.getlist('recipe_ids')
if recipe_ids:
form.fields['verb_id'].choices = get_verb_choices(recipe_ids)
form.fields['activity_type'].choices = get_activity_choices(
recipe_ids)
if result:
try:
result = json.dumps(json.loads(result.to_json()), indent=2)
except:
pass
return render(
request, self.template_name, {
'form': form,
'result': result,
'project_title': project_title,
'project_url': project_url
})
