def get_verb(self):
"""
Get verb for course enrollment statement.
"""
return Verb(
id=X_API_VERB_REGISTERED,
display=LanguageMap({'en-US': 'registered'}),
)
class CourseGradePassedFirstTimeTransformer(BaseEnrollmentTransformer):
"""
Transformers for event generated when learner pass course grade first time from a course.
"""
verb = Verb(
id=constants.XAPI_VERB_PASSED,
display=LanguageMap({constants.EN: constants.PASSED}),
)
class EnrollmentDeactivatedTransformer(BaseEnrollmentTransformer):
"""
Transformers for event generated when learner un-enrolls from a course.
"""
verb = Verb(
id=constants.XAPI_VERB_UNREGISTERED,
display=LanguageMap({constants.EN: constants.UNREGISTERED}),
)
def get_verb(self, event):
return Verb(
id=constants.XAPI_VERB_COMPLETED,
display=LanguageMap({
'en-US': 'completed',
'ru-RU': 'завершен'
}),
)
def get_verb(self):
"""
Get verb for the statement.
"""
return Verb(
id=X_API_VERB_COMPLETED,
display=LanguageMap({'en-US': 'completed'}),
)
def get_verb(self, event):
return Verb(
id=constants.XAPI_VERB_UNREGISTERED,
display=LanguageMap({
'en-US': 'unenrolled',
'en-GB': 'unenroled'
}),
)
def get_verb(self, event):
return Verb(
id=constants.XAPI_VERB_FAILED,
display=LanguageMap({
'en-US': 'failed',
'ru-RU': u'отчислен'
}),
)
def get_verb(self, event):
return Verb(
id=constants.XAPI_VERB_EXITED,
display=LanguageMap({
'en-US': 'exited',
'ru-RU': u'отчислился'
}),
)
def get_verb(self, event):
return Verb(
id=constants.XAPI_VERB_REGISTERED,
display=LanguageMap({
'en-US': 'registered',
'ru-RU': u'записался'
}),
)
def get_verb(self, event):
return Verb(
id=constants.XAPI_VERB_ATTACHED,
display=LanguageMap({
'en-US': 'attached',
'ru-RU': 'приложен'
}),
)
def generate(cls, verb):
if cls._validate_verb(verb):
verb_id = cls.verbs.get(verb)
return Verb(
id=verb_id,
display=LanguageMap({ 'en-US': verb })
)
return None
def sendstatement_joined_session(self, conn):
verb = Verb(
id='http://activitystrea.ms/schema/1.0/join',
display=LanguageMap({'en-US': 'joined'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._session_object)
self._send_to_LRS(statement)
def sendstatement_presentation_unloaded(self, conn):
verb = Verb(
id='https://iltserver.com/verbs/unloaded',
display=LanguageMap({'en-US': 'unloaded'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._presentation_object)
self._send_to_LRS(statement)
def sendstatement_presentation_launched(self, conn):
verb = Verb(
id='http://adlnet.gov/expapi/verbs/launched',
display=LanguageMap({'en-US': 'launched'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._presentation_object)
self._send_to_LRS(statement)
def test_InitVerb(self):
statement = Statement(verb=Verb(id='test'))
self.assertIsNone(statement.id)
self.assertIsNone(statement.actor)
self.assertIsNone(statement.object)
self.assertIsNone(statement.timestamp)
self.assertIsNone(statement.stored)
self.assertIsNone(statement.authority)
self.verbVerificationHelper(statement.verb)
def get_verb(self, event):
event_type = event['event_type'].replace("xblock-video.", "")
try:
verb_props = VIDEO_STATE_CHANGE_VERB_MAP[event_type]
except KeyError:
return None
return Verb(
id=verb_props['id'],
display=verb_props['display'],
)
def sendstatement_initialized_presentation(self, conn):
# sent when a participant's browser has finished loading the revealjs presentation
verb = Verb(
id='http://adlnet.gov/expapi/verbs/initialized',
display=LanguageMap({'en-US': 'initialized'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._presentation_object)
self._send_to_LRS(statement)
def test_ToJSON(self):
substatement = SubStatement(object_type='SubStatement',
actor=Agent(name='test'),
verb=Verb(id='test'),
object=Activity(id='test'))
self.assertEqual(
json.loads(substatement.to_json()),
json.loads(
'{"verb": {"id": "test"}, "object": {"id": "test", "objectType": "Activity"}, '
'"actor": {"name": "test", "objectType": "Agent"}, "objectType": "SubStatement"}'
))
def setUp(self):
self.endpoint = lrs_properties.endpoint
self.version = lrs_properties.version
self.username = lrs_properties.username
self.password = lrs_properties.password
self.lrs = RemoteLRS(
version=self.version,
endpoint=self.endpoint,
username=self.username,
password=self.password,
)
self.agent = Agent(mbox="mailto:[email protected]")
self.agent2 = Agent(mbox="mailto:[email protected]")
self.verb = Verb(id="http://adlnet.gov/expapi/verbs/experienced",
display=LanguageMap({"en-US": "experienced"}))
self.group = Group(member=[self.agent, self.agent2])
self.activity = Activity(
id="http://tincanapi.com/TinCanPython/Test/Unit/0",
definition=ActivityDefinition())
self.activity.definition.type = "http://id.tincanapi.com/activitytype/unit-test"
self.activity.definition.name = LanguageMap({"en-US": "Python Tests"})
self.activity.definition.description = LanguageMap(
{"en-US": "Unit test in the test suite for the Python library"})
self.activity.object_type = 'Activity'
self.parent = Activity(id="http://tincanapi.com/TinCanPython/Test",
definition=ActivityDefinition())
self.parent.definition.type = "http://id.tincanapi.com/activitytype/unit-test-suite"
self.parent.definition.name = LanguageMap({"en-US": "Python Tests"})
self.parent.definition.description = LanguageMap(
{"en-US": "Unit test in the test suite for the Python library"})
self.parent.object_type = 'Activity'
self.statement_ref = StatementRef(id=uuid.uuid4())
self.context = Context(registration=uuid.uuid4(),
statement=self.statement_ref)
# self.context.context_activities = ContextActivities(parent=[self.parent])
self.score = Score(raw=97, scaled=0.97, max=100, min=0)
self.result = Result(score=self.score,
success=True,
completion=True,
duration="PT120S")
self.substatement = SubStatement(
actor=self.agent,
verb=self.verb,
object=self.activity,
)
def sendstatement_completed_slide(self, conn, slide_info):
# sent when a participant's presentation leaves the current slide (we want to record duration)
# slide_info includes title (could be None) indexh and indexv
verb = Verb(
id='http://adlnet.gov/expapi/verbs/completed',
display=LanguageMap({'en-US': 'completed'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._make_slide_object(slide_info))
self._send_to_LRS(statement)
def get_verb(self, event):
event_type = event['event_type'].replace("xblock-video.", "")
try:
verb_props = VIDEO_STATE_CHANGE_VERB_MAP[event_type]
except KeyError:
return exceptions.XAPIBridgeSkippedConversion(
"unhandled video event: {}".event_type)
return Verb(
id=verb_props['id'],
display=verb_props['display'],
)
def test_build_statement(self):
"""
The build_statement function should return a valid tincan
Statement.
"""
user = UserFactory()
verb = Verb(
id="https://activitystrea.ms/schema/1.0/create",
display=LanguageMap({"en-US": "created"}),
)
activity = Activity(
id=f"id://ashley/topic/{uuid.uuid4()}",
definition=ActivityDefinition(
name=LanguageMap({"en-US": "test topic"}),
type="http://id.tincanapi.com/activitytype/discussion",
),
)
context = Context(context_activities=ContextActivities(parent=[
Activity(
id=f"uuid://{uuid.uuid4()}",
definition=ActivityDefinition(
name=LanguageMap({"en-US": "test forum"}),
type="http://id.tincanapi.com/activitytype/community-site",
),
)
]))
statement1 = build_statement(user, verb, activity, context)
statement2 = build_statement(user, verb, activity, context)
# The function should generate a random, non empty uuid as a
# statement ID
self.assertIsInstance(statement1.id, uuid.UUID)
self.assertIsInstance(statement2.id, uuid.UUID)
self.assertNotEqual(statement1.id, statement2.id)
# The statement id can also be specified
statement3_id = uuid.uuid4()
statement3 = build_statement(user, verb, activity, context,
statement3_id)
self.assertEqual(statement3_id, statement3.id)
# The verb, object and context should correspond to the given arguments
self.assertEqual(statement1.verb, verb)
self.assertEqual(statement1.object, activity)
self.assertEqual(statement1.context, context)
# The Actor part of the statement should reflect the user passed as an
# argument
self.assertEqual(statement1.actor.account.name,
user.lti_remote_user_id)
self.assertEqual(statement1.actor.account.home_page,
user.lti_consumer.url)
def sendstatement_attempted_slide(self, conn, slide_info):
# sent when a participant's presentation arrives at another slide
# slide_info includes title (could be None) indexh and indexv
# need to recalculate the id!
verb = Verb(
id='http://adlnet.gov/expapi/verbs/attempted',
display=LanguageMap({'en-US': 'attempted'}),
)
statement = Statement(actor=conn._actor,
verb=verb,
object=self._make_slide_object(slide_info))
self._send_to_LRS(statement)
def track_forum_view(sender, forum, user, request, response, **kwargs):
"""Log a XAPI statement when a user views a forum."""
parent_activities = None
consumer = getattr(user, "lti_consumer", None)
if consumer is None:
logger.warning("Unable to get LTI consumer of user %s", user)
return
xapi_logger = logging.getLogger(f"xapi.{user.lti_consumer.slug}")
verb = Verb(
id="http://id.tincanapi.com/verb/viewed",
display=LanguageMap({"en-US": "viewed"}),
)
obj = Activity(
id=f"id://ashley/forum/{forum.pk}",
definition=ActivityDefinition(
name=LanguageMap(
{to_locale(settings.LANGUAGE_CODE).replace("_", "-"): forum.name}
),
type="http://id.tincanapi.com/activitytype/community-site",
),
)
if request.forum_permission_handler.current_lti_context_id is not None:
try:
lti_context = LTIContext.objects.get(
pk=request.forum_permission_handler.current_lti_context_id
)
parent_activities = [
Activity(
id=lti_context.lti_id,
definition=ActivityDefinition(
type="http://adlnet.gov/expapi/activities/course"
),
)
]
except LTIContext.DoesNotExist:
pass
if parent_activities is not None:
context = Context(
context_activities=ContextActivities(parent=parent_activities),
)
else:
context = None
statement = build_statement(user, verb, obj, context)
if statement:
xapi_logger.info(statement.to_json())
def sendstatement_unlocked_followme(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/follow-me': 'off'}))
statement = Statement(actor=conn._actor,
verb=verb,
object=self._presentation_object,
result=result_obj)
self._send_to_LRS(statement)
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_session_ended(self):
aname = 'sysadmin'
actor = Agent(
name=aname,
mbox='mailto:' + aname + '@iltserver.com',
)
verb = Verb(
id='http://adlnet.gov/expapi/verbs/terminated',
display=LanguageMap({'en-US': 'terminated'}),
)
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 get_verb(self):
"""
Get verb for xAPI transformed event.
Returns:
`Verb`
"""
event_name = self.get_data('name', True)
if self.get_data('context.event_source') == 'browser' and event_name == 'problem_check':
verb = self.verb_map['problem_check_browser']
else:
verb = self.verb_map[event_name]
return Verb(
id=verb['id'],
display=LanguageMap({constants.EN: verb['display']})
)
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,
)
